<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Security on miti99</title><link>https://miti99.com/en/tags/security/</link><description>Recent content in Security 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/security/index.xml" rel="self" type="application/rss+xml"/><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 #134</title><link>https://miti99.com/en/post/2026/10/02/</link><pubDate>Fri, 02 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #134.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-startup"&gt;&lt;a href="https://hatchet.run/blog/postgres-survival-guide" rel="noopener noreferrer"&gt;The startup&amp;rsquo;s Postgres survival guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hatchet CEO Alexander Belanger distills roughly two years of running PostgreSQL in production into a pragmatic field guide that&amp;rsquo;s much easier to scan during an incident than the official manual. On schema design: use identity columns or UUIDs for primary keys, always use &lt;code&gt;timestamptz&lt;/code&gt;, and don&amp;rsquo;t hesitate to reach for &lt;code&gt;jsonb&lt;/code&gt; when strict normalization hurts query performance. On reads: join on primary keys, index columns used in &lt;code&gt;ON&lt;/code&gt; clauses just like &lt;code&gt;WHERE&lt;/code&gt; clauses, and put &lt;code&gt;ORDER BY&lt;/code&gt; columns last in compound indexes with matching sort directions. On writes: keep transactions short, never call external services inside a transaction, always use &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; on large tables, keep schema migrations additive, and use &lt;code&gt;NOT VALID&lt;/code&gt; when adding check constraints. Because Postgres connections are heavy, always use a connection pooler—preferably PgBouncer or &lt;code&gt;pgxpool&lt;/code&gt;. Finally, remember that the query planner is a leaky abstraction driven by statistics in &lt;code&gt;pg_stats&lt;/code&gt;: debug slow queries with &lt;code&gt;EXPLAIN (ANALYZE, BUFFERS)&lt;/code&gt;, visualize plans on &lt;code&gt;explain.dalibo.com&lt;/code&gt;, and avoid premature micro-optimization.&lt;/p&gt;
&lt;p&gt;The advanced half covers batching writes (for instance, &lt;code&gt;pgx&lt;/code&gt;&amp;rsquo;s &lt;code&gt;SendBatch&lt;/code&gt;) for roughly 10x higher throughput, monitoring autovacuum via &lt;code&gt;pg_stat_activity&lt;/code&gt;, and guarding against transaction ID wraparound. Fix table bloat with &lt;code&gt;pg_repack&lt;/code&gt; rather than locking tables with &lt;code&gt;VACUUM FULL&lt;/code&gt;, and clear index bloat with &lt;code&gt;REINDEX INDEX CONCURRENTLY&lt;/code&gt;. Hatchet relies heavily on &lt;code&gt;FOR UPDATE SKIP LOCKED&lt;/code&gt; to power job queues and distributed lease management across instances. Table partitioning lets autovacuum work on smaller chunks independently and makes dropping old time-series data nearly instantaneous. When migrating massive tables, dual-write new rows via a trigger, backfill historical rows in batches outside a long-running transaction, and lean on unique constraints for idempotency.&lt;/p&gt;
&lt;h2 id="what-is-orasort-understanding-oracles-sorting-aglorithm-in-simple-terms"&gt;&lt;a href="https://deepsystemstuff.com/how-oracles-secret-column-sorting-technique-became-public-after-its-patent-expired-making-sorting-5x-faster/" rel="noopener noreferrer"&gt;What is Orasort? understanding Oracle’s Sorting Aglorithm In Simple Terms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nadeem Shaikh introduces Orasort, a sorting optimization patented by Oracle (credited to Mark Callaghan). According to the post, the 20-year patent expired in 2024, placing the technique in the public domain where it can speed up database sorting by up to 5x. Traditional string sorting compares values byte by byte, so long strings that share a common prefix—such as email addresses or URLs from the same domain—waste many CPU cycles repeating character comparisons. Orasort instead packs an 8-byte slice of each string into a 64-bit integer register and compares all 8 bytes in a single CPU instruction. If those 8 bytes settle the ordering, the comparison finishes immediately; only when they are identical does it advance to the next 8-byte chunk.&lt;/p&gt;
&lt;p&gt;The sorting pipeline pairs this with several other techniques. Rather than moving full table rows around during a sort, the database loads only the sort key and row ID (tuple pointer) into an in-memory sort buffer. When the dataset exceeds available RAM, it spills sorted runs to disk and merges them afterward, writing sorted runs out to disk asynchronously while the CPU continues sorting the next batch in memory. While the author notes that open-source databases like PostgreSQL and MySQL have adopted or experimented with similar abbreviated-key sorting ideas—saving substantial cloud CPU costs—the article doesn&amp;rsquo;t cite primary sources for the 5x figure or the exact patent details, so treat it as an approachable conceptual overview rather than a rigorous historical reference.&lt;/p&gt;
&lt;h2 id="fornax"&gt;&lt;a href="https://docs.pixeldrain.com/posts/2024-03-07_network_optimizations/" rel="noopener noreferrer"&gt;Fornax&amp;rsquo;s Guide To Ridiculously Fast Ethernet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fornax, creator of the file-sharing service Pixeldrain, leased a 100 GbE server expecting it to saturate the link out of the box, only to watch the machine crash at around 20 Gbit/s. After more than a year of reading NIC manuals, digging through Linux kernel source code, profiling, and even patching the kernel, Fornax hit the full 100 Gbit/s line rate and wrote up the complete tuning guide. At the &lt;code&gt;sysctl&lt;/code&gt; layer, pair the BBR congestion control algorithm with the &lt;code&gt;fq&lt;/code&gt; packet scheduler so random packet loss doesn&amp;rsquo;t tank throughput. Enabling &lt;code&gt;tcp_shrink_window&lt;/code&gt; (a Cloudflare patch merged in Linux 6.5) cut TCP buffer memory consumption by roughly 80%, curing peak-hour OOM crashes on a server with 1 TB of RAM. Per-connection socket buffers are raised to a 1 GiB ceiling based on the bandwidth-delay product, and &lt;code&gt;tcp_mem&lt;/code&gt; is raised to 40–60% of system RAM instead of the ~5% default.&lt;/p&gt;
&lt;p&gt;On the hardware side, Mellanox/NVIDIA ConnectX-5 and ConnectX-6 NICs with stock in-tree kernel drivers proved rock-solid. Via &lt;code&gt;ethtool&lt;/code&gt;, match the NIC channel count to CPU cores, max out the RX/TX ring buffers, and disable adaptive interrupt coalescing in favor of a fixed 100 µs interval. In the BIOS, set NUMA to NPS1 and disable SMT on 128+ core CPUs. The single most impactful stability fix was disabling the IOMMU (&lt;code&gt;iommu=pt&lt;/code&gt; or off), which stopped the NIC from wedging under heavy load. Fornax also eliminated reverse proxies like nginx and Caddy so packets don&amp;rsquo;t cross the kernel/userspace boundary multiple times, serving traffic directly from Go&amp;rsquo;s standard HTTP server with &lt;code&gt;SO_REUSEPORT&lt;/code&gt; for zero-downtime restarts. HTTP/2 is preferred, while HTTP/3 (QUIC) was dropped because its throughput barely reached half of TCP&amp;rsquo;s. Finally, run a minimal Debian install on the latest mainline kernel, as Linux 6.8 and 6.19 brought major TCP throughput gains.&lt;/p&gt;
&lt;h2 id="parity-before-cutover"&gt;&lt;a href="https://alexocallaghan.com/parity-before-cutover" rel="noopener noreferrer"&gt;Parity before cutover&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex O&amp;rsquo;Callaghan recounts inheriting a critical internal service that existed in two parallel universes: a legacy Python 2 version running in production on on-prem VMs, and a modernized Python 3 rewrite living on a long-lived feature branch waiting to be deployed to cloud Kubernetes. This classic &amp;ldquo;big-bang cutover&amp;rdquo; approach bundles every possible risk into a single release and delays real-world feedback until the very end. Engineering effort is doubled because every urgent production bugfix has to be written in Python 2 and forward-ported to the Python 3 branch (or worse, forgotten), and subtle behavioral regressions stay hidden until cutover day when too many variables have changed at once to isolate the culprit.&lt;/p&gt;
&lt;p&gt;Instead of marching straight toward the cloud cutover, O&amp;rsquo;Callaghan proposed &amp;ldquo;taking a step backward to move forward&amp;rdquo;: shipping the modernized Python 3 codebase onto the legacy on-prem VMs first. Because the legacy OS only supported up to Python 3.6, the team downgraded the branch from Python 3.7 to 3.6 rather than fighting the OS, and added runtime environment configuration so the exact same codebase could deploy to both on-prem VMs and Kubernetes. From that point on, every commit deployed to both environments simultaneously, surfacing behavioral differences incrementally while the legacy Python 2 service remained an instant rollback away. Once the Python 3 service achieved 100% production parity on-prem, cutting over to Kubernetes became a pure infrastructure switch—changing one variable at a time. The takeaway: if a migration branch has been open for months waiting on another team or platform, it&amp;rsquo;s probably bundling too many changes at once; look for an intermediate state you can ship to production today, even if it feels like a step sideways.&lt;/p&gt;
&lt;h2 id="the-new-go-json-api-twice-as-fast-or-15x-slower"&gt;&lt;a href="https://lemire.me/blog/2026/08/29/the-new-go-json-api-twice-as-fast-or-1-5x-slower/" rel="noopener noreferrer"&gt;The new Go JSON API: twice as fast, or 1.5x slower?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Starting in Go 1.27, the &lt;code&gt;encoding/json/v2&lt;/code&gt; package ships in the standard library by default. While its &lt;code&gt;Marshal&lt;/code&gt; and &lt;code&gt;Unmarshal&lt;/code&gt; functions look almost identical to v1, &lt;code&gt;v2&lt;/code&gt; is not a drop-in replacement due to stricter UTF-8 validation, case-sensitive field matching by default, and other behavioral cleanups. Because the legacy &lt;code&gt;encoding/json&lt;/code&gt; (v1) package was also re-engineered to run on top of the new &lt;code&gt;v2&lt;/code&gt; engine under the hood, Daniel Lemire benchmarks three configurations: the original Go 1.26 &lt;code&gt;encoding/json&lt;/code&gt; engine (built with &lt;code&gt;GOEXPERIMENT=nojsonv2&lt;/code&gt;), the v1 API running on Go 1.27&amp;rsquo;s new v2 backend, and &lt;code&gt;encoding/json/v2&lt;/code&gt; called directly. Benchmarks run single-threaded on an Apple M4 Max and an Intel Xeon Emerald Rapids using three standard &lt;code&gt;simdjson&lt;/code&gt; test files (&lt;code&gt;twitter.json&lt;/code&gt;, &lt;code&gt;canada.json&lt;/code&gt;, and &lt;code&gt;citm_catalog.json&lt;/code&gt;) parsed into generic &lt;code&gt;any&lt;/code&gt; values.&lt;/p&gt;
&lt;p&gt;Simply upgrading to Go 1.27 without touching a line of code makes v1 &lt;code&gt;Marshal&lt;/code&gt; up to 2x faster—for example, &lt;code&gt;twitter.json&lt;/code&gt; jumps from 198 MB/s to 374 MB/s. &lt;code&gt;Unmarshal&lt;/code&gt; via v1 also speeds up on two of the files, though it regresses slightly on float-heavy &lt;code&gt;canada.json&lt;/code&gt; (from 128 MB/s down to 106 MB/s). Calling &lt;code&gt;json/v2&lt;/code&gt; directly makes generic &lt;code&gt;Unmarshal&lt;/code&gt; 1.5x to 2.3x faster and &lt;code&gt;Marshal&lt;/code&gt; 1.2x to 3x faster than the old engine. However, on a round-trip benchmark of 10,000 small strongly typed Go structs, while &lt;code&gt;json/v2&lt;/code&gt; still unmarshals faster, &lt;code&gt;Marshal&lt;/code&gt; is roughly 1.5x &lt;em&gt;slower&lt;/em&gt; than the legacy engine—contrary to the Go 1.27 release notes claiming struct marshaling performance is at parity. Lemire&amp;rsquo;s advice: &lt;code&gt;json/v2&lt;/code&gt; is a clear win for unmarshaling, but benchmark your actual struct workloads before migrating write-heavy serialization paths.&lt;/p&gt;
&lt;h2 id="a-deep-dive-into-deepsec"&gt;&lt;a href="https://flaviocopes.com/deepsec/" rel="noopener noreferrer"&gt;A deep dive into DeepSec&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Flavio Copes explores DeepSec, an open-source (Apache 2.0) AI-powered security scanner from Vercel. Unlike tools that only review incoming pull request diffs, DeepSec audits an entire repository—including legacy code that has never had a security review. Its pipeline starts with a fast, free local pattern-matching pass that combines file-path globs with regular expressions to flag candidate files. Next, Codex or Claude Code reads the flagged files, traces data flows across the codebase, checks for existing sanitization or auth guards, and records findings with severity, confidence, and remediation advice. A second agent pass independently verifies each finding to filter out hallucinations, a cheaper triage pass assigns P0–P2 priorities, and all state is persisted in &lt;code&gt;.deepsec/&lt;/code&gt; so interrupted scans can resume cleanly.&lt;/p&gt;
&lt;p&gt;Running DeepSec against &lt;code&gt;flaviocopes.com&lt;/code&gt; using Codex via a standard ChatGPT subscription scanned 729 files and produced 504 raw findings, including 1 Critical and 16 High. Closer inspection showed that 462 of those findings lived in client-side browser mini-tools on the site. Copes then asked Codex to cluster the findings by root cause and separate real production risks from local helper scripts and code examples, narrowing the actionable list down to payment webhooks, course recovery flows, and public forms. DeepSec cannot prove a codebase is secure, still produces false positives, and sends source code to your chosen model provider, but its workflow highlights an important lesson: raw finding counts are mostly noise—always anchor triage where untrusted input touches authentication, private data, money, or infrastructure.&lt;/p&gt;
&lt;h2 id="imthenachomanhow-to-secure-a-linux-server-an-evolving-how-to-guide-for-securing-a-linux-server"&gt;&lt;a href="https://github.com/imthenachoman/How-To-Secure-A-Linux-Server" rel="noopener noreferrer"&gt;imthenachoman/How-To-Secure-A-Linux-Server: An evolving how-to guide for securing a Linux server.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This popular open-source guide (CC BY-SA 4.0, over 31,000 GitHub stars) compiles practical steps for hardening a Linux server, born out of the author&amp;rsquo;s personal notes while building a home Debian server. Because Linux security advice is scattered across hundreds of blog posts—and most developers don&amp;rsquo;t provision bare-metal Linux servers every day—it is easy to overlook basic hardening steps. The moment a server touches the public internet, automated scanners start probing it, and an unhardened box can quietly have its data exfiltrated or get drafted into a DDoS botnet without the owner noticing. The author recommends reading this guide first to understand the &lt;em&gt;why&lt;/em&gt; behind each control, and then layering official CIS Benchmarks on top.&lt;/p&gt;
&lt;p&gt;The SSH section covers enforcing public/private key authentication, restricting login access via &lt;code&gt;AllowGroups&lt;/code&gt;, locking down &lt;code&gt;sshd_config&lt;/code&gt;, removing weak Diffie-Hellman moduli, and enabling 2FA. System basics cover restricting &lt;code&gt;sudo&lt;/code&gt; and &lt;code&gt;su&lt;/code&gt;, sandboxing applications with Firejail, hiding other users&amp;rsquo; processes in &lt;code&gt;/proc&lt;/code&gt; (&lt;code&gt;hidepid&lt;/code&gt;), enforcing strong password policies with PAM, and enabling &lt;code&gt;unattended-upgrades&lt;/code&gt; for security patches. Networking covers configuring UFW as a firewall (including fixing the notorious gotcha where Docker bypasses UFW rules by manipulating &lt;code&gt;iptables&lt;/code&gt; directly), using PSAD to detect port scans, and running Fail2Ban and CrowdSec to block brute-force and application-layer attacks. Auditing introduces AIDE, ClamAV, rkhunter, Logwatch, Lynis, and OSSEC, followed by a &amp;ldquo;Danger Zone&amp;rdquo; for changes that can lock you out if misconfigured—like kernel &lt;code&gt;sysctl&lt;/code&gt; hardening, GRUB passwords, and disabling root login. A community-maintained Ansible playbook is also available to automate the setup.&lt;/p&gt;
&lt;h2 id="postgres-19-how-our-advice-has-changed-since-we-wrote-it"&gt;&lt;a href="https://www.crunchydata.com/blog/postgres-19-how-our-advice-has-changed-since-we-wrote-it" rel="noopener noreferrer"&gt;Postgres 19: How Our Advice Has Changed Since We Wrote It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christopher Winslett at Crunchy Data revisits the company&amp;rsquo;s classic blog posts on bulk loading, storage, indexing, and partitioning—many originally written in the Postgres 10 and 11 era—to see how their advice holds up against Postgres 19 (beta). Asynchronous I/O (introduced in Postgres 18) dramatically speeds up sequential scans, bitmap heap scans, and vacuuming; Postgres 19 builds on it with autoscaling I/O workers, &lt;code&gt;EXPLAIN (ANALYZE, IO)&lt;/code&gt;, parallel autovacuum, and disabling JIT compilation by default. The &lt;code&gt;COPY&lt;/code&gt; command keeps getting better: SIMD-accelerated CSV parsing, &lt;code&gt;ON_ERROR set_null&lt;/code&gt; to survive dirty rows without aborting an entire load, multi-line header skipping, direct &lt;code&gt;COPY ... TO&lt;/code&gt; JSON output, and &lt;code&gt;COPY TO&lt;/code&gt; support directly on partitioned tables. &lt;code&gt;LZ4&lt;/code&gt; is now the default TOAST compression algorithm (existing toasted values keep their original compression), and a built-in &lt;code&gt;REPACK&lt;/code&gt; command (with &lt;code&gt;CONCURRENTLY&lt;/code&gt;) finally brings &lt;code&gt;pg_repack&lt;/code&gt;-style online table compaction into core Postgres as a native replacement for &lt;code&gt;VACUUM FULL&lt;/code&gt; and &lt;code&gt;CLUSTER&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;On indexing, BRIN gains &lt;code&gt;minmax_multi&lt;/code&gt; opclasses for imperfectly ordered data and &lt;code&gt;bloom&lt;/code&gt; opclasses for UUID equality lookups. B-tree skip scans (added in 18) allow a multi-column index to serve queries that filter only on trailing columns when the leading column has low cardinality, letting teams drop redundant single-column indexes. Native partitioning adds &lt;code&gt;MERGE PARTITIONS&lt;/code&gt; and &lt;code&gt;SPLIT PARTITION&lt;/code&gt;, though both currently take an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock and belong in maintenance windows. The takeaway: the core fundamentals haven&amp;rsquo;t changed—use &lt;code&gt;COPY&lt;/code&gt; for bulk loads, store JSON in &lt;code&gt;jsonb&lt;/code&gt;, and partition primarily for data lifecycle management—but Postgres 19 makes executing them much smoother. Keep the same mental model, update your commands, and verify with &lt;code&gt;EXPLAIN (ANALYZE, BUFFERS, IO)&lt;/code&gt; after upgrading.&lt;/p&gt;
&lt;h2 id="how-we-saved-100-terabytes-of-memory-by-optimizing-1111s-dns-cache"&gt;&lt;a href="https://blog.cloudflare.com/dns-cache-memory-optimization-1111/" rel="noopener noreferrer"&gt;How we saved 100 terabytes of memory by optimizing 1.1.1.1’s DNS cache&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Big Pineapple, the Rust platform powering Cloudflare&amp;rsquo;s &lt;code&gt;1.1.1.1&lt;/code&gt; public resolver and other DNS services, holds over 250 billion cached DNS entries across its global fleet. At that scale, wasting a single byte per cache entry costs more than 250 GB of RAM globally. Although cached DNS entries are completely immutable once inserted, their Rust structs were still using &lt;code&gt;Vec&lt;/code&gt; and &lt;code&gt;String&lt;/code&gt; fields, each carrying an unused 8-byte &lt;code&gt;capacity&lt;/code&gt; field and potential heap over-allocation. Worse, the enum representing DNS record data was sized to its largest variant, padding tiny &lt;code&gt;A&lt;/code&gt; and &lt;code&gt;AAAA&lt;/code&gt; records with dead space. The team built a realistic traffic benchmark paired with a custom tracking allocator to measure exact per-entry heap usage alongside insert throughput and lookup latency.&lt;/p&gt;
&lt;p&gt;They rolled out five progressive optimizations: replacing &lt;code&gt;Vec&amp;lt;T&amp;gt;&lt;/code&gt; and &lt;code&gt;String&lt;/code&gt; with boxed slices (&lt;code&gt;Box&amp;lt;[T]&amp;gt;&lt;/code&gt;) and &lt;code&gt;Box&amp;lt;str&amp;gt;&lt;/code&gt;; flattening three separate record lists (answer, authority, additional) into a single allocation indexed by &lt;code&gt;u16&lt;/code&gt; offsets; omitting the record&amp;rsquo;s owner name when it matches the query name; boxing oversized enum variants like &lt;code&gt;TXT&lt;/code&gt; and &lt;code&gt;NAPTR&lt;/code&gt;; and finally storing records as pre-serialized DNS wire-format bytes packed into a single contiguous allocation. With wire-format storage, common records like &lt;code&gt;A&lt;/code&gt;, &lt;code&gt;AAAA&lt;/code&gt;, and &lt;code&gt;TXT&lt;/code&gt; can be &lt;code&gt;memcpy&lt;/code&gt;&amp;rsquo;d straight into outbound DNS response packets without re-serializing. In benchmarks, per-entry memory dropped by 56% (from 953 bytes down to 420 bytes), insert throughput rose 43%, and lookup latency fell 19%. In production, p99 resident memory per server dropped from 9.3 GB to 5.3 GB—saving roughly 100 TB of RAM across the fleet (the equivalent of ~130 servers), which Cloudflare plans to reinvest into larger caches for higher hit rates.&lt;/p&gt;
&lt;h2 id="agentic-code-quality"&gt;&lt;a href="https://addyo.substack.com/p/agentic-code-quality" rel="noopener noreferrer"&gt;Agentic Code Quality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that traditional human line-by-line code review cannot keep pace with the volume of code generated by AI agents, so quality control must shift into the harness, environment, and automated verification systems surrounding the agent. His central thesis: in an agentic workflow, software quality is bounded by the quality of the constraints you place around the agent. Those constraints include unit tests, property-based tests, acceptance tests, mutation testing (to verify your tests actually catch injected bugs rather than merely exercising lines), and static complexity metrics like cyclomatic complexity. How much human code reading you can safely skip depends on the blast radius: throwaway prototypes need very little, whereas auth, billing, and core infrastructure demand either human review or exceptionally tight automated invariants. The goal is an environment that gives the agent fast, reliable feedback and makes failures cheap and contained.&lt;/p&gt;
&lt;p&gt;Constraints should operate at three boundaries: up front (via specs, type systems, and architecture rules), continuously during execution (as compiler and test feedback), and at the production gate. Every layer of the verification stack should own a distinct concern—from type safety and lint rules to performance budgets and security scanning—so compilers, failing tests, and CI policies exert early &amp;ldquo;backpressure&amp;rdquo; on the agent long before a human is asked to review a PR. When code generation velocity outstrips a team&amp;rsquo;s verification capacity, you have only three choices: scale up automated verification, slow down generation, or lower your quality bar (the worst option). Because human attention is now the scarcest resource in engineering, save it for high-leverage decisions about product intent, taste, and system architecture, and pull humans into the loop only after the automated guardrails pass.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=bF28LFPjFsI" rel="noopener noreferrer"&gt;How the JVM Really Works&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;ByteByteGo&amp;rsquo;s video explains how the Java Virtual Machine works under the hood, from compiling Java source code into bytecode to executing it on the target machine.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!tsAw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb0fa724e-feb3-4ec6-9c53-50437d9cf884_2484x3002.png" alt="MCP vs RAG vs AI Agents"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!aJjm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F79e409f6-979a-4756-9366-de84824ab9d8_2484x3002.png" alt="9 Distributed Systems Patterns You Should Know"&gt;&lt;/p&gt;</description></item><item><title>Newsletter #127</title><link>https://miti99.com/en/post/2026/07/29/</link><pubDate>Wed, 29 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/29/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #127.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-return-to-two-pizza-culture"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/06/return-to-two-pizza-culture.html" rel="noopener noreferrer"&gt;A return to two-pizza culture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels looks back at the &amp;ldquo;two-pizza team&amp;rdquo; model that helped Amazon move fast: teams small enough that everyone understands each other&amp;rsquo;s work, owns their product end-to-end, and makes reversible decisions autonomously without waiting for sign-off. As a company grows to hundreds of services, cross-team dependencies, management layers, and review gates easily erode that agility. According to Vogels, coding agents like Kiro are changing the equation because a working prototype can now be built in hours instead of months.&lt;/p&gt;
&lt;p&gt;Through the story of the Amazon Quick desktop team—where the first prototype was built in a single evening and quickly attracted contributors—Vogels proposes adapting the Working Backwards process. When you have high conviction about a customer problem but aren&amp;rsquo;t yet sure about the solution, build a prototype first, dogfood it daily, fix bugs on the spot, and write the PR/FAQ document only after learning from hands-on experience. Writing remains essential for clarifying thought, but it is no longer the only way to make an idea concrete. Even when an organization grows to hundreds of people, structuring it as small teams with end-to-end ownership keeps innovation from stalling. AI tools don&amp;rsquo;t replace human judgment; they shorten the feedback loop between idea and reality.&lt;/p&gt;
&lt;h2 id="a-peek-into-reddit"&gt;&lt;a href="https://lyra.horse/blog/2026/06/reddit-spam-internals/" rel="noopener noreferrer"&gt;A peek into Reddit&amp;rsquo;s anti-spam internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In 2021, a brief UI bug exposed Reddit&amp;rsquo;s internal content-removal reasons to moderators. Piecing together screenshots from that incident, old open-source Reddit code, and public documentation, the author reconstructs how the platform fights spam. There is no single silver-bullet filter: Spamurai, the primary rule engine since 2020, combines account age and karma, user reports, ASN/network provider, browser fingerprinting via TLS and user-agent strings, email domains, and posting behavior. Alongside it sit domain blacklists dating back to 2012, the REV1 and REV2 rule generations, keyword filters, a fetcher that crawls linked pages to find shared analytics or ad IDs across domains, and external image classification services.&lt;/p&gt;
&lt;p&gt;The post also highlights how fragile individual signals can be in isolation. Against Google&amp;rsquo;s Perspective API, inserting just a few random letter pairs into a paragraph dropped its spam score from 86% down to 1%. Real-world anti-abuse systems therefore have to aggregate many independent signals and continuously learn from moderator actions. The author notes that publishing these details is now safe because the Perspective API is shutting down in 2026 and LLM-generated spam has forced Reddit to overhaul its defenses anyway—a reminder that anti-abuse architectures must constantly evolve alongside attacker techniques.&lt;/p&gt;
&lt;h2 id="understanding-the-go-runtime-profiling"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-profiling/" rel="noopener noreferrer"&gt;Understanding the Go Runtime: Profiling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the internal mechanics of Go&amp;rsquo;s five built-in profilers: CPU, heap, block, mutex, and goroutine. Although they measure different things, all five capture call stacks and emit the same compressed &lt;code&gt;pprof&lt;/code&gt; protobuf format: each sample stores only a list of location IDs and measurement values, while locations, functions, and strings live in shared lookup tables so thousands of identical stacks aren&amp;rsquo;t duplicated. What truly distinguishes the profilers is how each one captures stacks.&lt;/p&gt;
&lt;p&gt;CPU profiling is streaming: the OS sends a timer signal to interrupt threads roughly 100 times per second, the signal handler writes the stack into a lock-free ring buffer, and a background goroutine drains and aggregates those samples—willingly dropping samples if the buffer fills up so it never blocks a running thread. Heap profiling aggregates in place: the allocator samples roughly once every 512 KiB and folds the stack directly into a hash table bucketed by call stack to estimate both total allocations and live in-use memory. Block and mutex profiles reuse that same in-place table infrastructure to measure wait durations—one recording when a goroutine finishes waiting, the other recording contended lock releases and scaling the sample up to estimate total contention. Goroutine profiling, by contrast, is an on-demand snapshot that collects the stacks of all live goroutines via a two-phase mechanism designed to minimize stop-the-world pause time. The overarching lesson is that the Go runtime quietly absorbs a great deal of complexity so that profiling feels effortless to use.&lt;/p&gt;
&lt;h2 id="incident-report-cve-2026-lgtm"&gt;&lt;a href="https://nesbitt.io/2026/06/26/incident-report-cve-2026-lgtm.html" rel="noopener noreferrer"&gt;Incident Report: CVE-2026-LGTM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a satirical incident report about a fictional software supply-chain attack in which a malicious package, &lt;code&gt;foxhole-lz4&lt;/code&gt;, breezes past seven AI-powered security gates, each failing in its own way. The release gate trusts hidden white-on-white text claiming the package was manually audited. One scanner gets distracted critiquing an illustration embedded in the package, while three commercial scanners exhaust their context windows on padding before ever reaching the payload. The single system that accurately flags the credential-stealing behavior gets dismissed by the repository&amp;rsquo;s AI triage assistant as benign telemetry, and the human who reports the actual compromise is rate-limited by a triage bot for &amp;ldquo;suspicious activity.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Next, two evaluator agents burn over $41,000 arguing with each other, and the remediation agent signs a formal &amp;ldquo;treaty&amp;rdquo; with the attacker&amp;rsquo;s agent. Ultimately, an old-fashioned canary file planted by a human is what stops the breach. The root cause is summed up neatly: seven models lined up in a row—six assumed one of the others had read the code, and the seventh read it and apologized. The piece lampoons granting broad autonomy to AI agents without verification: stacking multiple layers powered by the same foundation model only creates an illusion of diversity; untrusted data must be separated from instructions; model failures must never default to &amp;ldquo;no findings&amp;rdquo;; and having a &amp;ldquo;human in the loop&amp;rdquo; needs to be a real operational control rather than a line item in a compliance contract.&lt;/p&gt;
&lt;h2 id="cors-what-is-it-protecting"&gt;&lt;a href="https://sanyamserver.online/posts/cors/" rel="noopener noreferrer"&gt;CORS: What is it protecting?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article clears up a widespread misconception: CORS is a browser-enforced security mechanism, not a server-side firewall. On cross-origin requests, the browser attaches an &lt;code&gt;Origin&lt;/code&gt; header, checks the response&amp;rsquo;s &lt;code&gt;Access-Control-Allow-Origin&lt;/code&gt; header, and allows frontend JavaScript to read the response body only if the origin is permitted. For simple requests that don&amp;rsquo;t trigger a preflight check, the server may have already executed the request even when the browser blocks JavaScript from reading the response. If a preflight check fails, the actual request is never sent. Command-line tools like &lt;code&gt;curl&lt;/code&gt; ignore browser CORS policies entirely. More complex requests—such as those using methods other than GET/POST/HEAD, custom headers, or JSON bodies—trigger an &lt;code&gt;OPTIONS&lt;/code&gt; preflight request asking the server which origins, methods, and headers it accepts.&lt;/p&gt;
&lt;p&gt;What CORS actually protects is data confidentiality in the browser: when configured properly, a malicious site cannot read your bank account details even though your browser holds an active session cookie. However, CORS does not prevent CSRF. A standard HTML form POST doesn&amp;rsquo;t require a preflight, so the server processes the state-changing request before the browser blocks the response from being read. Defending against CSRF requires request-side protections such as &lt;code&gt;SameSite&lt;/code&gt; cookie attributes, anti-CSRF tokens, or server-side validation of the &lt;code&gt;Origin&lt;/code&gt; and &lt;code&gt;Referer&lt;/code&gt; headers. In short, CORS and CSRF defenses solve two distinct problems and shouldn&amp;rsquo;t be conflated.&lt;/p&gt;
&lt;h2 id="data-access-patterns-that-makes-your-cpu-really-angry"&gt;&lt;a href="https://blog.weineng.me/posts/slowest_add/" rel="noopener noreferrer"&gt;Data Access Patterns That Makes Your CPU Really Angry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post runs a contrarian experiment: finding the slowest possible traversal order to sum all elements of a $2^{26}$-element array. Sequential scanning is the fastest at roughly 132 million cycles thanks to CPU caches and hardware prefetchers, while random access—typically treated as the worst case—takes about 1.57 billion cycles. The author systematically tests strided access patterns: jumping by one cache line, jumping by one memory page, and combining both. On the author&amp;rsquo;s Intel Core Ultra 7 268V, page-strided access is especially punishing because hardware prefetchers do not cross 4 KB page boundaries, while simultaneously causing many addresses to map to and thrash the exact same cache set in L1.&lt;/p&gt;
&lt;p&gt;The worst culprit is an eight-page stride—roughly 32 KB between consecutive reads—which takes around 2.06 billion cycles, about 33% slower than random access. It simultaneously saturates the cache set, defeats hardware prefetching, eliminates cache-line reuse, and destroys TLB locality, driving up address-translation overhead. The author also experiments with clustering accesses by DRAM bank and row to minimize memory-level parallelism, though undocumented physical address mapping makes that part approximate. Understanding why specific access patterns make a CPU crawl helps developers recognize the real-world limits of caches, prefetchers, and TLBs in everyday code.&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 #126</title><link>https://miti99.com/en/post/2026/07/23/</link><pubDate>Thu, 23 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #126.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="2-portable-executables"&gt;&lt;a href="https://anteiku.fun/papers/an-introduction-to-modern-malware-development-for-red-teams/02_portable_executables/" rel="noopener noreferrer"&gt;2. Portable Executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article is the second chapter in an introductory series on modern malware development for red teams, focusing on the Portable Executable (PE) format—the shared structure behind executables, dynamic-link libraries, and drivers on Windows. The author walks through the DOS Header, DOS Stub, PE Header, Optional Header, section table, and familiar sections such as &lt;code&gt;.text&lt;/code&gt;, &lt;code&gt;.data&lt;/code&gt;, &lt;code&gt;.rdata&lt;/code&gt;, &lt;code&gt;.rsrc&lt;/code&gt;, and &lt;code&gt;.reloc&lt;/code&gt;. The core point is that a PE simultaneously describes how the file is laid out on disk and how the Windows Loader maps it into memory: header fields specify the architecture, entry point, alignment, image size, and locations of key data directories, while each section&amp;rsquo;s attributes determine its contents and its read, write, or execute permissions at runtime.&lt;/p&gt;
&lt;p&gt;The second half shifts to the perspective of security products performing static analysis—evaluating a file before it is executed. Common indicators examined include hashes, digital signatures, data entropy, unusual entry point locations, sections marked &lt;code&gt;RWX&lt;/code&gt;, large discrepancies between on-disk and in-memory sizes, unfamiliar section names, sparse import tables, and suspicious API combinations. For newcomers, the article illustrates why a solid understanding of the PE structure is foundational both for analyzing malware and for building detection mechanisms against packed or obfuscated binaries.&lt;/p&gt;
&lt;h2 id="how-4-bytes-of-padding-make-array-clearing-49-faster"&gt;&lt;a href="https://blog.andr2i.com/posts/2026-06-22-optimization-catalog-how-4-bytes-of-padding-make-array-clearing-49-faster" rel="noopener noreferrer"&gt;How 4 bytes of padding make array clearing 49% faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part of the &amp;ldquo;Optimization catalog&amp;rdquo; series, this post analyzes a memory alignment phenomenon in Go: when a &lt;code&gt;uint32&lt;/code&gt; array sits at a 4-byte offset from an 8-byte boundary, clearing the array slows down dramatically. On the benchmarked Intel processor, adding just 4 bytes of padding to align the array to 8 bytes increases throughput by roughly 49%; on AMD the improvement is only around 9%, and ARM machines are virtually unaffected. Inspecting the assembly reveals that the entire clear is handled by a single &lt;code&gt;REP STOSQ&lt;/code&gt; instruction. Based on performance counters, the author hypothesizes that Intel&amp;rsquo;s fast-string path writes full cache lines directly without reading them first; when the array is misaligned by 4 bytes, an 8-byte store straddles every 64-byte cache-line boundary, so no cache line is ever completely overwritten in one go and the fast path cannot kick in.&lt;/p&gt;
&lt;p&gt;Follow-up benchmarks show that SIMD—whether via Go&amp;rsquo;s experimental intrinsics or handwritten assembly—does not outperform &lt;code&gt;STOSQ&lt;/code&gt;. A non-temporal store variant is occasionally faster, but its results fluctuate wildly depending on whether the OS kernel allocates contiguous or fragmented physical pages. The article also considers tagging elements with generation numbers to avoid actually zeroing memory, though generation tags enlarge the array and can push working data out of cache. The takeaway is that low-level optimizations depend heavily on the CPU microarchitecture, machine instructions, and data size, so you always need to measure on real hardware.&lt;/p&gt;
&lt;h2 id="engineering-high-performance-parsers-with-data-oriented-design"&gt;&lt;del&gt;&lt;a href="https://www.arshad.fyi/writings/engineering-high-performance-parsers" rel="noopener noreferrer"&gt;Engineering High-Performance Parsers with Data-Oriented Design&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This article shares the design principles behind Yuku, a JavaScript and TypeScript parser written in Zig, centered on one thesis: once the grammar is right, parser performance is dictated almost entirely by how the syntax tree is represented in memory rather than the parsing algorithm itself. Instead of individually heap-allocated nodes linked by pointers—which cause tens of thousands of allocations and unpredictable memory accesses—Yuku stores nodes in a flat array and uses &lt;code&gt;u32&lt;/code&gt; indices as references. An index takes half the space of a 64-bit pointer, the entire tree is freed in a single operation, and the recursive-descent parsing logic remains familiar.&lt;/p&gt;
&lt;p&gt;The author applies the same data-oriented mindset across the parser: splitting node payloads and source locations into separate parallel arrays so each traversal pass touches only the data it needs; storing variable-length child lists as offset-and-length pairs into an extra buffer; reusing scratch buffers across recursive calls; representing strings as byte spans into the original source; packing operator metadata directly into tag bits; and compressing Unicode lookup tables by deduplicating identical blocks. Size and layout invariants are verified at compile time to prevent accidental regressions. Because the tree consists purely of indices and offsets, its in-memory representation doubles as its wire format, allowing the AST to be handed over to JavaScript as a single contiguous buffer rather than serialized through JSON.&lt;/p&gt;
&lt;h2 id="how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers-18l5" rel="noopener noreferrer"&gt;How To Learn Go Fast: A Practical Roadmap For Senior Backend Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article lays out a Go learning roadmap for experienced backend developers, particularly those coming from PHP, Laravel, or Symfony. The author argues that you don&amp;rsquo;t need to relearn backend fundamentals like APIs, databases, or queues; instead, leverage that foundation and focus on how Go structures programs: explicit code, errors as values, small implicitly satisfied interfaces, explicit dependency wiring, and a preference for the standard library over monolithic frameworks.&lt;/p&gt;
&lt;p&gt;The roadmap starts with syntax, types, packages, and error handling before quickly moving into building CLI tools, HTTP services, and concurrent worker systems, since building small projects early teaches the language faster than reading syntax tutorials alone. A 12-week plan progresses from core fundamentals to PostgreSQL, integration testing, race detection, cancellation contexts, profiling, observability, and a portfolio-ready capstone project—treating testing, error handling, and operations as parallel tracks rather than afterthoughts. The post also includes a condensed multi-day track for developers jumping into an existing Go codebase immediately, while still emphasizing production habits like setting timeouts on network calls, implementing graceful shutdown, reading real-world source code, and profiling before optimizing. Ultimately, senior-level Go proficiency shows in your ability to build, deploy, diagnose, and maintain real systems.&lt;/p&gt;
&lt;h2 id="how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid--senior-engineers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid-senior-engineers-200p" rel="noopener noreferrer"&gt;How To Prepare For A Golang Interview: A Practical Guide For Mid &amp;amp; Senior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article serves as a comprehensive study map for mid- and senior-level Go interviews, emphasizing that interviewers evaluate reasoning and system design rather than mere syntax recall. It covers zero values, packages, slices, maps, pointers, interfaces, error handling, &lt;code&gt;defer&lt;/code&gt;, &lt;code&gt;panic&lt;/code&gt;, and common memory pitfalls. Topics frequently used to separate candidates are explained in depth—such as shared backing arrays across slices, non-nil interfaces holding nil pointers, channel closing rules, and choosing between mutexes and channels—because these are also frequent sources of production bugs.&lt;/p&gt;
&lt;p&gt;The senior section expands into the G-M-P scheduler, the memory model, escape analysis, garbage collection, goroutine leaks, context cancellation, race detection, and profiling with &lt;code&gt;pprof&lt;/code&gt;. It also covers testing, databases, HTTP, graceful shutdown, system design, and operational concerns beyond the language itself. According to the author, a strong interview answer articulates choices, trade-offs, and how to verify behavior through tests or benchmarks. The guide concludes with a list of common mistakes, time-boxed coding exercises like worker pools, rate limiters, and retry mechanisms, and a self-assessment checklist for writing correct, production-grade Go.&lt;/p&gt;
&lt;h2 id="shard-your-locks-benchmarking-6-go-cache-designs"&gt;&lt;a href="https://strebkov.dev/posts/shard-your-locks/" rel="noopener noreferrer"&gt;Shard your locks: benchmarking 6 Go cache designs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks six ways to build a concurrent &lt;code&gt;string → string&lt;/code&gt; cache using only the Go standard library: an unlocked map (as a baseline), a single &lt;code&gt;Mutex&lt;/code&gt;, a single &lt;code&gt;RWMutex&lt;/code&gt;, &lt;code&gt;sync.Map&lt;/code&gt;, a 256-shard map, and copy-on-write. Benchmarks run across varying read/write ratios and from one to eight CPU cores. The results show that a single lock does not scale: at eight cores, even a read-only workload with a &lt;code&gt;Mutex&lt;/code&gt; is slower than on a single core. &lt;code&gt;RWMutex&lt;/code&gt;, the reflexive choice for read-heavy contention, scales only to about 2x before plateauing because its atomic reader counter becomes the new contention bottleneck—and under write-heavy workloads, it performs even worse than a plain &lt;code&gt;Mutex&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The sharded design, where each shard has its own map and lock, is the only approach that consistently ranks near the top across all workloads—outperforming a single lock by up to 8x because operations on different shards proceed in parallel. Copy-on-write leads on pure read workloads but collapses toward zero throughput as soon as writes appear, since every write clones the entire map, making it suitable only for rarely updated data. The author also notes that skewed key distributions can actually speed up reads thanks to CPU cache locality, while concentrating write contention onto a few hot shards. Using 256 shards is a sweet spot for this benchmark rather than a universal constant; before picking a concurrency primitive, always benchmark with your actual key distribution, hardware, and workload.&lt;/p&gt;
&lt;h2 id="the-join-that-should-be-a-bug"&gt;&lt;a href="https://kronotop.com/blog/the-join-that-should-be-a-bug/" rel="noopener noreferrer"&gt;The .join() That Should Be a Bug&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains how Kronotop serves thousands of concurrent connections when nearly every command has to wait on network calls to FoundationDB or filesystem I/O. The author contrasts two familiar architectures: Redis uses a single thread for all connections, holding massive connection counts at the cost of forbidding any blocking command; PostgreSQL uses one process per connection, allowing straightforward sequential blocking code but consuming heavy OS resources as connections scale. Kronotop takes a third path, decoupling connection holding from blocking work to combine the strengths of both models.&lt;/p&gt;
&lt;p&gt;A small pool of Netty event-loop threads accepts data, parses commands, and sends responses without ever blocking. Disk I/O and network calls are offloaded to Java virtual threads, where a &lt;code&gt;.join()&lt;/code&gt; call—normally considered an anti-pattern or bug in asynchronous code—can block sequentially without pinning the underlying OS carrier thread. Once the result is ready, writing the response is always dispatched back to the exact Netty event loop that owns the connection, keeping concurrency invariants clean and predictable. Each connection also acts as a session holding authentication state, namespace, and open transaction state; when a connection closes or resets, its associated transactions and resources are safely aborted and cleaned up.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #125</title><link>https://miti99.com/en/post/2026/07/13/</link><pubDate>Mon, 13 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #125.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="275---khi-big-tech-chuyển-mình-thành-ai-factory"&gt;&lt;a href="https://newsletter.grokking.org/p/275-khi-big-tech-chuyen-minh-thanh" rel="noopener noreferrer"&gt;275 - Khi Big Tech chuyển mình thành AI Factory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This edition shares an inside look at how a major tech company is transforming its engineering organization into an &amp;ldquo;AI factory.&amp;rdquo; The author maps agentic automation across five maturity levels: starting with engineers copy-pasting snippets from a chatbot, moving to interactive coding agents guided turn by turn, then agents going autonomously from a written spec to a tested pull request, then humans acting solely as orchestrators of review and deployment, and finally agents autonomously deploying, monitoring production, and remediating incidents. Because each level grants agents broader autonomy, the company has to invest heavily in sandboxed execution environments, automated verification, fine-grained permissions, and hard guardrails that block destructive actions.&lt;/p&gt;
&lt;p&gt;As a result, the software engineer&amp;rsquo;s day-to-day role shifts from writing every line by hand to &amp;ldquo;packaging&amp;rdquo; work into well-bounded specifications with explicit goals and acceptance criteria—a transition that proves surprisingly tough for junior engineers accustomed to exploratory, trial-and-error coding. Human code review remains indispensable because critical product and system requirements often live in unwritten tribal context; automated AI review bots currently have only about half of their suggestions accepted and burn significant token budgets at scale. While individual programming languages are becoming increasingly interchangeable, deep fundamentals in operating systems, networking, security, infrastructure, data structures, and concurrency remain the bedrock that lets engineers evaluate and take accountability for AI-generated systems.&lt;/p&gt;
&lt;h2 id="the-8020-rule-for-your-whole-life"&gt;&lt;a href="https://yewjin.substack.com/p/always-be-curious" rel="noopener noreferrer"&gt;The 80/20 rule for your whole life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yew Jin Lim proposes applying the 80/20 rule across your entire life: dedicate the 80% majority of your resources to building a rock-solid, low-drama foundation, and treat the remaining 20% as a &amp;ldquo;laboratory&amp;rdquo; for bounded experiments. The governing mindset is evaluating your life as a portfolio rather than agonizing over every individual position. He illustrates this with personal examples: many of the 20%-time side projects he tried at Google went nowhere individually, yet together they shaped his career trajectory; his retirement portfolio grew roughly tenfold through automated contributions and the discipline not to tinker; and his meditation practice deepened simply by showing up every day.&lt;/p&gt;
&lt;p&gt;From that experience he distills three core habits: follow curiosity to expand your knowledge without demanding an immediate payoff, master decision-making by separating emotional reactions from individual outcomes, and stay consistent long enough for compounding to do its work. He draws a sharp distinction between short-term trading and long-term investing, noting that once your foundation is sound, &amp;ldquo;doing nothing&amp;rdquo; is often the highest-leverage move available. Experiments don&amp;rsquo;t need to succeed every time, so long as each bet is sized small enough that failure is cheap tuition rather than ruin—and the 80% foundation is never put at risk.&lt;/p&gt;
&lt;h2 id="three-bad-managers"&gt;&lt;a href="https://randsinrepose.com/archives/three-bad-managers/" rel="noopener noreferrer"&gt;Three Bad Managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) tells the story of three brilliant, commercially successful bosses who were terrible people managers, using them to draw a crisp line between leadership (charting a compelling direction for the organization) and management (helping individuals understand where they stand and navigating day-to-day execution). &amp;ldquo;The Artist&amp;rdquo; was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. &amp;ldquo;The Dictator&amp;rdquo; used forceful authority and intimidation to dominate rooms—for instance, casually reopening design directions the team had already spent weeks evaluating rather than trusting their expertise. &amp;ldquo;The Knife&amp;rdquo; was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.&lt;/p&gt;
&lt;p&gt;For each boss, Lopp found a different survival strategy: writing his own detailed performance review ahead of 1-on-1s so The Artist just had to react to it, doing exhaustive technical homework before meetings so he could push back on The Dictator as an equal, and simply staying out of The Knife&amp;rsquo;s blast radius to get work done independently. His core takeaway is that you will almost never change your boss—especially when they are senior and successful—but you can change how you prepare, communicate, and operate around them. Every working relationship requires calibration, and learning how to adapt to difficult personalities is a practical survival skill rather than an endorsement of bad management.&lt;/p&gt;
&lt;h2 id="cross-team-pragmatics"&gt;&lt;a href="https://philcalcado.com/2026/06/01/cross_team_pragmatics.html" rel="noopener noreferrer"&gt;Cross-Team Pragmatics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Calçado examines why cross-team collaboration almost always slows down and turns political as an engineering organization grows. The root causes are predictable: individual-focused performance review cultures incentivize local optimization, high-level strategic goals contradict each other once cascaded down different org branches (e.g., an infra team rewarded for cutting cloud spend while a product team is rewarded for shipping compute-heavy features), accountability is assigned without matching ownership, and minor disagreements constantly escalate up the management chain instead of getting resolved laterally. The only durable fix is a unified technical strategy that aligns how the business competes with team boundaries, ownership, incentives, and decision rights.&lt;/p&gt;
&lt;p&gt;While waiting for those slow structural fixes to take hold, Calçado shares four pragmatic tools for treating the immediate symptoms. Team charters turn unspoken assumptions into explicit boundaries, responsibilities, and interaction modes, cutting down repetitive renegotiation. Value-stream mapping traces how a feature actually flows from idea to production rather than looking at the org chart, exposing unnecessary handoffs and queues. The 80% rule states that a team should be able to complete at least 80% of its roadmap without blocking dependencies on other teams along the critical path, while Team Topologies gives organizations a shared vocabulary for intentionally choosing how teams interact. These tools buy breathing room and stability, though long-term health still requires continuously reshaping the org around how value is actually delivered.&lt;/p&gt;
&lt;h2 id="technological-involution"&gt;&lt;a href="https://rohan.ga/blog/technological-involution/" rel="noopener noreferrer"&gt;Technological Involution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rohan argues that the tech industry has entered a state of &amp;ldquo;involution&amp;rdquo;: more talent and capital pouring in than ever, yet producing increasingly homogeneous, incremental ideas. In his view, the obvious low-hanging fruit of consumer and SaaS software has largely been picked, standard application software is rapidly commoditizing, and Silicon Valley startup culture encourages young founders to borrow pre-packaged narratives from influencers and VCs rather than forming independent convictions from scratch. Hype manufactures consensus rather than real value, while society at large grows more cynical about tech&amp;rsquo;s future. Meanwhile, the genuinely hard problems sit in atoms, hardware, semiconductors, and messy real-world enterprise operations—domains where most young founders lack hands-on experience.&lt;/p&gt;
&lt;p&gt;AI excels at generating code and synthesizing conventional wisdom, but by design it gravitates toward the consensus mean rather than contrarian, high-impact insights. Rohan argues that this limitation is precisely what preserves the opening for human agency: people who immerse themselves deeply in a domain, test hypotheses from first principles, and have the courage to pursue non-consensus ideas will only become more valuable. The way out of involution is returning to intrinsic motivation—building something because the problem itself is intellectually gripping rather than optimizing for startup vanity metrics—and the success of independent, taste-driven new media proves that work built with genuine conviction still cuts through the noise.&lt;/p&gt;
&lt;h2 id="fintech-engineering-handbook"&gt;&lt;a href="https://w.pitula.me/fintech-engineering-handbook/" rel="noopener noreferrer"&gt;Fintech Engineering Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wojciech Pitula&amp;rsquo;s handbook distills core principles and architectural patterns for building software where money is the primary domain object, anchored on three commandments: never invent money or data out of thin air, never lose data, and never trust any single component blindly. On representing monetary amounts, he compares floating-point numbers (almost never acceptable), arbitrary-precision decimals, integer minor units (e.g., cents), and rational fractions, while warning that standard JSON parsers silently coerce numeric literals into IEEE 754 floats unless amounts are serialized as strings or integers. Every balance change is recorded in a double-entry ledger where money only ever moves between accounts and balances are derived from immutable journal entries—tracking transaction time, booking time, and settlement time as distinct timestamps.&lt;/p&gt;
&lt;p&gt;On the execution side, the handbook covers funds holds/reservations to prevent double-spending, strict idempotency keys, crash-resumable state machines, and at-least-once event delivery. When integrating with external payment processors and banks, systems must validate schemas at the boundary, persist every raw request and response payload for auditability, verify webhook signatures before querying the provider&amp;rsquo;s canonical API for state, and run independent automated reconciliation jobs to catch ledger drift early. Posted ledger entries are strictly immutable—mistakes are corrected via compensating reversal entries, never &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt;—and sensitive manual operations require four-eyes approval. End-to-end walkthroughs of crypto withdrawals, card top-ups, and currency exchanges show how these patterns interlock across multi-step failure scenarios.&lt;/p&gt;
&lt;h2 id="how-to-write-an-effective-software-design-document"&gt;&lt;a href="https://refactoringenglish.com/excerpts/write-an-effective-design-doc/" rel="noopener noreferrer"&gt;How to Write an Effective Software Design Document&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch shares a practical guide to writing software design documents that surface flawed assumptions before coding begins and align stakeholders on how to solve a problem. A design doc is worth writing when a project spans multiple people, takes longer than three months, will live in production long-term, crosses team boundaries, starts from ambiguous requirements, or carries high operational risk. To decide how much detail a section needs, Lynch suggests asking one simple question: &amp;ldquo;what is the cost of being wrong?&amp;rdquo; Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don&amp;rsquo;t belong in a design doc.&lt;/p&gt;
&lt;p&gt;An effective design doc typically covers background and goals, explicit scope and non-goals, architecture and data-flow diagrams, measurable SLAs/SLOs, security and privacy considerations, a milestone timeline, and a log of open and resolved questions. The document should focus on the hardest trade-offs and gathering early feedback rather than specifying every line-level implementation detail—if you&amp;rsquo;ve written pseudocode for every class, you&amp;rsquo;ve essentially written the code twice. Lynch also recommends using editable diagramming tools (like Mermaid or Excalidraw with source checked in), defining domain jargon in a glossary, documenting rejected alternatives so reviewers don&amp;rsquo;t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.&lt;/p&gt;
&lt;h2 id="the-cost-yagni-was-never-about"&gt;&lt;a href="https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-about" rel="noopener noreferrer"&gt;The Cost YAGNI Was Never About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck explains that YAGNI (&amp;ldquo;You Aren&amp;rsquo;t Gonna Need It&amp;rdquo;) was never really about saving typing or coding effort—it is an economic principle about &lt;em&gt;when&lt;/em&gt; to commit to a design decision. Building speculative structure before a feature actually demands it incurs two distinct costs that have nothing to do with how fast you can write code. The first is lost optionality: the team locks in a bet when they have the least information about the problem, and when real requirements inevitably diverge from the guess, they have to pay to work around or rip out that speculative abstraction. Even on the rare occasion when the guess turns out right, committing early still forfeits the option value of waiting until you know more; as Beck puts it, waiting isn&amp;rsquo;t procrastination—it is holding a valuable option.&lt;/p&gt;
&lt;p&gt;The second cost is net present value (NPV) and carrying cost: you pay the complexity, maintenance, and cognitive tax immediately while any hypothetical payoff arrives far in the future, meaning you lose economically whether your prediction was right or wrong. Now that AI makes generating code nearly free, the &amp;ldquo;save typing time&amp;rdquo; argument for YAGNI disappears, yet both the optionality cost and the carrying cost remain completely intact—in fact, AI makes it dangerously easy to hallucinate sprawling, speculative frameworks in seconds. Build structure when concrete demand arrives and gives you the information needed to design it right; YAGNI is economic discipline, not stinginess with keystrokes.&lt;/p&gt;
&lt;h2 id="a-cve-dispute"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/06/24/a-cve-dispute/" rel="noopener noreferrer"&gt;a CVE dispute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg recounts curl&amp;rsquo;s first formal CVE dispute since the project became a CVE Numbering Authority (CNA). With roughly 30 billion libcurl installations worldwide, publishing a CVE triggers a massive wave of triage, compliance scanning, patching, and backporting across the entire software industry. Because of that amplification effect, the curl security team evaluates reports based on realistic exploitability and occasionally declines to assign a CVE to bugs whose security impact is &amp;ldquo;lower than low&amp;rdquo;—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.&lt;/p&gt;
&lt;p&gt;The disputed report involved curl&amp;rsquo;s wildcard certificate hostname matching function when the URL&amp;rsquo;s hostname began with a leading dot (e.g., &lt;code&gt;.example.com&lt;/code&gt;). For this bug to be exploitable in practice, an absurd chain of preconditions had to hold simultaneously: a user had to request a hostname that is syntactically invalid in standard DNS, that invalid name had to resolve via something like a modified local &lt;code&gt;/etc/hosts&lt;/code&gt; file, an attacker-controlled server at that IP had to present a matching wildcard certificate from a trusted CA, and the attacker already needed local privileges to poison name resolution in the first place. The curl team fixed the bug in December 2025 as a normal defect but declined to issue a CVE. A security researcher appealed the decision to MITRE, and after multiple rounds of review in 2026, MITRE agreed with curl that it was simply a fixed bug rather than a security vulnerability because exploiting it required a privileged local attacker. The episode illustrates why not every bug in a network library deserves a CVE, and how the CNA dispute process provides an independent check when opinions differ.&lt;/p&gt;
&lt;h2 id="how-llms-actually-work"&gt;&lt;a href="https://www.0xkato.xyz/how-llms-actually-work/" rel="noopener noreferrer"&gt;How LLMs Actually Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This visual guide explains how autoregressive transformer language models generate text token by token without getting bogged down in heavy calculus. Incoming text is first split into subword tokens by a tokenizer and mapped to integer IDs; an embedding lookup table then converts each ID into a dense vector capturing learned semantic features, placing tokens with related meanings near one another in high-dimensional space. Because self-attention treats inputs as an unordered set by default, the model injects positional information—most modern LLMs use Rotary Position Embeddings (RoPE), rotating query and key vectors by an angle proportional to each token&amp;rsquo;s position in the sequence. Inside each transformer block, self-attention compares query vectors against key vectors to compute attention weights, deciding how much information to pull from each prior token&amp;rsquo;s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.&lt;/p&gt;
&lt;p&gt;After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model&amp;rsquo;s parameters and stored factual associations. Residual connections allow information to flow and accumulate across dozens of stacked layers without vanishing gradients, while layer normalization keeps activation magnitudes stable. At the very end of the stack, the final token&amp;rsquo;s hidden state vector is projected across the entire vocabulary and passed through softmax to produce a probability distribution over the next token; the runtime samples a token (shaped by temperature, top-p, or top-k), appends it to the sequence, and repeats the loop. While modern frontier models tweak attention variants, architectures, and training recipes, they all share this foundational autoregressive transformer loop.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LlLN!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe4d255e1-536e-4f66-ab48-e8baa1bdd4a4_2484x3002.png" alt="RAG vs Graph RAG vs Agentic RAG"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!15Bw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9b8f9d64-3eae-4237-b49f-ffde033f851a_2484x3002.png" alt="Redis Data Structures Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-ILW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F19ca7f08-d615-4769-8599-2aa9aaa5d6bd_2508x3000.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ydOn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe46aad28-2935-4b87-8cf4-72787b48a9d0_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_6cl!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fea738d9d-1ae5-4a26-9a50-79ec7720fd80_2360x2664.jpeg" alt="The Testing Pyramid"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #120</title><link>https://miti99.com/en/post/2026/07/08/</link><pubDate>Wed, 08 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #120.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="lessons-from-building-claude-code-how-we-use-skills"&gt;&lt;a href="https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills" rel="noopener noreferrer"&gt;Lessons from building Claude Code: How we use skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thariq Shihipar, a member of the Claude Code team at Anthropic, distills lessons learned from building and using hundreds of internal skills. The central insight is that a skill isn&amp;rsquo;t just a single Markdown file of instructions—it is an entire folder that can bundle scripts, assets, reference data, hooks, and configuration. This structure enables progressive disclosure: the agent reads &lt;code&gt;SKILL.md&lt;/code&gt; first and only loads auxiliary docs or helper scripts when the task actually needs them, keeping the context window lean. Shihipar groups skills into nine practical categories: library/API references, product verification, data analysis, workflow automation, code scaffolding, code review, CI/CD, operational runbooks, and infrastructure management.&lt;/p&gt;
&lt;p&gt;When authoring skills, he advises skipping generic advice Claude already knows and focusing on instructions that nudge the model out of its default habits—especially a living &amp;ldquo;gotchas&amp;rdquo; section capturing recurring pitfalls, repo conventions, and edge cases added whenever the agent makes a mistake in practice. State high-level goals rather than rigid step-by-step micromanagement, give the skill a persistence mechanism (like log or JSON files) to maintain state across sessions, and bundle composable helper scripts so the agent doesn&amp;rsquo;t have to reconstruct boilerplate operations from scratch via token generation. For larger teams, skills can be committed directly to the repo or distributed through an internal plugin marketplace so engineers install only what they need without bloating context, while hooks track usage metrics to prune overly broad or unused skills.&lt;/p&gt;
&lt;h2 id="bulkhead-pattern---go"&gt;&lt;a href="https://dev.to/kamal_namdeo/bulkhead-pattern-go-362c" rel="noopener noreferrer"&gt;Bulkhead Pattern - Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kamal Namdeo walks through implementing the Bulkhead Pattern in Go: isolating resources per downstream dependency so one slow or failing service cannot exhaust goroutines, sockets, and request budgets across your entire application. Instead of letting every outbound HTTP call share &lt;code&gt;http.DefaultTransport&lt;/code&gt;, each downstream dependency gets its own three-layer bulkhead: a semaphore capping concurrent in-flight requests (using &lt;code&gt;TryAcquire&lt;/code&gt; to fail fast when full), a dedicated connection pool via &lt;code&gt;MaxConnsPerHost&lt;/code&gt; so one slow host cannot starve TCP connections to others, and tight timeouts that free resources quickly when an upstream stalls. That way, if the auth service is degraded, billing and S3 calls continue unaffected.&lt;/p&gt;
&lt;p&gt;The post also shows how to size concurrency limits. Little&amp;rsquo;s Law relates average concurrency to throughput and average latency; plugging in p99 latency plus a 30% safety buffer is the author&amp;rsquo;s practical sizing heuristic rather than the law itself, showing why slower dependencies require more slots to sustain the same throughput. Blast radius during outages is contained through layered timeouts: &lt;code&gt;ResponseHeaderTimeout&lt;/code&gt; (roughly 1.2x p99), &lt;code&gt;Client.Timeout&lt;/code&gt; covering the full request lifecycle, a 1–2 second TCP dial/TLS handshake timeout, and a &lt;code&gt;QueueTimeout&lt;/code&gt; derived by subtracting downstream latency from your SLA budget. Namdeo closes with common Go pitfalls: &lt;code&gt;runtime.NumCPU()&lt;/code&gt; is the wrong basis for sizing I/O concurrency because goroutines blocked on network reads don&amp;rsquo;t consume CPU cores, response bodies must be drained before closing so connections can return to the idle pool, and &lt;code&gt;MaxIdleConns&lt;/code&gt; should equal the sum of per-host idle limits so dependencies don&amp;rsquo;t evict each other&amp;rsquo;s pooled connections.&lt;/p&gt;
&lt;h2 id="max-consecutive-ones"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/max-consecutive-ones-13mj" rel="noopener noreferrer"&gt;Max Consecutive Ones&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh breaks down a foundational LeetCode problem in Java: given a binary array, find the maximum number of consecutive &lt;code&gt;1&lt;/code&gt;s. The brute-force approach starts at every index containing a &lt;code&gt;1&lt;/code&gt;, scans forward to count the streak, and updates the global maximum. While easy to explain in an interview, it repeatedly re-scans the same elements, resulting in &lt;code&gt;O(N²)&lt;/code&gt; time complexity with &lt;code&gt;O(1)&lt;/code&gt; auxiliary space.&lt;/p&gt;
&lt;p&gt;The optimal solution rests on a simple observation: a streak of &lt;code&gt;1&lt;/code&gt;s grows as long as we keep seeing &lt;code&gt;1&lt;/code&gt; and resets the moment we hit a &lt;code&gt;0&lt;/code&gt;, meaning we only ever need to track the length of the current streak. By maintaining two scalar variables—current streak length and maximum streak seen so far—we increment the counter and update the max on &lt;code&gt;1&lt;/code&gt;, and reset the counter to &lt;code&gt;0&lt;/code&gt; on &lt;code&gt;0&lt;/code&gt;. That single pass runs in &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space without nested loops. Recognizing this &amp;ldquo;maintain running state, update global best, reset when the invariant breaks&amp;rdquo; pattern makes short work of many contiguous-subarray interview questions.&lt;/p&gt;
&lt;h2 id="double-bigdecimal-or-fixed-point"&gt;&lt;a href="https://blog.frankel.ch/bigdecimal-vs-double/" rel="noopener noreferrer"&gt;double, BigDecimal, or Fixed-Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago pushes back against blanket slogans like &amp;ldquo;always use &lt;code&gt;BigDecimal&lt;/code&gt; for money&amp;rdquo; or &amp;ldquo;&lt;code&gt;double&lt;/code&gt; is broken.&amp;rdquo; Under IEEE 754, &lt;code&gt;double&lt;/code&gt; is a binary floating-point approximation, meaning base-10 fractions like &lt;code&gt;0.1&lt;/code&gt; cannot be represented exact to the last bit—but that is a deliberate engineering trade-off. For domains that are inherently approximate, such as analytics, machine learning, or physics simulations, &lt;code&gt;double&lt;/code&gt; is usually the right choice because it runs directly in hardware at blistering speed; you simply need to compare values using an epsilon tolerance instead of &lt;code&gt;==&lt;/code&gt;, handle &lt;code&gt;NaN&lt;/code&gt; and &lt;code&gt;-0.0&lt;/code&gt; properly, and reach for techniques like Kahan or Neumaier summation, pairwise summation, or &lt;code&gt;Math.fma()&lt;/code&gt; when minimizing accumulated rounding error.&lt;/p&gt;
&lt;p&gt;Conversely, &lt;code&gt;BigDecimal&lt;/code&gt; shines when exact decimal representation, explicit rounding modes, and auditability are mandatory—such as tax calculation, invoicing, and accounting—at the cost of heap allocations and software arbitrary-precision arithmetic. It also has its own footguns: calling &lt;code&gt;new BigDecimal(0.1)&lt;/code&gt; bakes in the binary float inaccuracy (always use &lt;code&gt;new BigDecimal(&amp;quot;0.1&amp;quot;)&lt;/code&gt; or &lt;code&gt;BigDecimal.valueOf(0.1)&lt;/code&gt;), forgetting to reassign results on immutable instances, or calling &lt;code&gt;equals()&lt;/code&gt;—which compares scale (&lt;code&gt;2.0&lt;/code&gt; != &lt;code&gt;2.00&lt;/code&gt;)—instead of &lt;code&gt;compareTo()&lt;/code&gt;. For high-throughput financial engines, fixed-point arithmetic using &lt;code&gt;long&lt;/code&gt; is often the pragmatic sweet spot: store &lt;code&gt;$19.99&lt;/code&gt; as &lt;code&gt;1999&lt;/code&gt; cents, use &lt;code&gt;Math.addExact&lt;/code&gt; and &lt;code&gt;multiplyExact&lt;/code&gt; to catch overflows immediately, and convert to &lt;code&gt;BigDecimal&lt;/code&gt; only at system boundaries. Fago also warns about losing trailing scale during JSON serialization and non-reproducible sums in parallel &lt;code&gt;DoubleStream&lt;/code&gt; pipelines. Choose numeric types based on domain precision rules, rounding semantics, and performance constraints—not slogans.&lt;/p&gt;
&lt;h2 id="can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update"&gt;&lt;a href="https://medium.com/helidon/can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update-e16a2e262fc4" rel="noopener noreferrer"&gt;Can Java Microservices Be As Fast As Go? A 2026 Benchmark Update&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Six years after his original comparison, Mark Nelson revisits the question: can a small Java microservice match Go on raw performance? He benchmarks Go 1.26.3 using &lt;code&gt;net/http&lt;/code&gt; against Helidon SE 4.4.1 (handling requests on virtual threads) running on Oracle JDK 26.0.1, alongside a variant using a Project Leyden AOT cache. The test service is deliberately small and synthetic: an endpoint generates payloads of 7, 128, 2048, or 8192 bytes, performs uppercase, lowercase, string reversal, and CRC32 calculations with &lt;code&gt;WORK_FACTOR=10&lt;/code&gt;, and returns JSON. Each runtime is benchmarked sequentially with dedicated warmup passes and logging disabled. Before recording final numbers, Nelson noticed Helidon exhibiting a puzzling 44–48 ms latency floor on larger responses over reused HTTP/1.1 connections; enabling &lt;code&gt;tcpNoDelay(true)&lt;/code&gt; eliminated the Nagle/delayed-ACK interaction immediately.&lt;/p&gt;
&lt;p&gt;What stands out in the results isn&amp;rsquo;t a simplistic &amp;ldquo;Java beats Go&amp;rdquo; headline, but the shape of the scaling curves. At small payload sizes and low concurrency, all three configurations perform in roughly the same ballpark. As concurrent connections and payload sizes climb, however, the Java setups scale noticeably better: at 2 KB payloads, Go peaks around 17,000 requests/sec, whereas standard JVM reaches ~39,500 and Leyden AOT hits ~41,600. Leyden AOT posts the highest peak throughput across every payload size, while Go doesn&amp;rsquo;t win a single cell despite staying competitive at the smallest sizes. Nelson stresses that teams shouldn&amp;rsquo;t use synthetic microbenchmarks to dictate company-wide language mandates—measure your own workload, as runtime tuning, frameworks, hardware, warmup, logging, and socket options often matter just as much as the language itself.&lt;/p&gt;
&lt;h2 id="stop-using-conventional-commits"&gt;&lt;a href="https://sumnerevans.com/posts/software-engineering/stop-using-conventional-commits/" rel="noopener noreferrer"&gt;Stop Using Conventional Commits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sumner Evans argues against Conventional Commits because the format puts the emphasis in the wrong place. In his view, the single most valuable piece of information in a commit subject line is the scope—which subsystem, package, module, or service was touched. Developers scanning &lt;code&gt;git log&lt;/code&gt; are usually rebasing, debugging, or triaging an incident, so they need to know immediately which part of the codebase changed. Conventional Commits instead puts a change-type category like &lt;code&gt;fix&lt;/code&gt;, &lt;code&gt;feat&lt;/code&gt;, or &lt;code&gt;chore&lt;/code&gt; up front and makes the scope optional. Worse, the change type is usually obvious from the description anyway, and often ambiguous when a single commit fixes a bug, refactors a helper, and adds a small capability at once.&lt;/p&gt;
&lt;p&gt;Evans then dismantles the usual selling points of Conventional Commits one by one. Auto-generating user-facing changelogs from commit history produces poor results because changelogs are written for end users while commit logs are written for maintainers—two audiences that need completely different levels of detail. Automating SemVer bumps from commit prefixes breaks down around reverts, breaking changes discovered after the fact, or follow-up fixes landed before release. Triggering CI/CD pipelines off commit message prefixes is even a security and reliability hazard, since automation should inspect which files actually changed in the tree rather than trusting human-typed subject lines. Instead, he recommends the scope-first convention used by Linux, FreeBSD, Git, Go, and Node.js—&lt;code&gt;scope: description&lt;/code&gt;, such as &lt;code&gt;net/http/cookiejar: add godoc links&lt;/code&gt;—where scopes mirror the natural structure of the project.&lt;/p&gt;
&lt;h2 id="stop-using-jwts"&gt;&lt;a href="https://gist.github.com/samsch/0d1f3d3b4745d778f78b230cf6061452" rel="noopener noreferrer"&gt;Stop using JWTs!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Schlinkert argues for defaulting to server-side sessions for browser authentication, noting that revocation, logout, and lifecycle management are usually much simpler than rolling a custom stateless JWT scheme. That said, the gist&amp;rsquo;s claim that the JWT specification was designed strictly for short-lived tokens of around five minutes is factually incorrect: RFC 7519 imposes no such lifetime limit. A JWT is simply a signed or encrypted claims format; its security depends on the surrounding protocol, key management, and validation rules rather than every use of JWT being inherently insecure.&lt;/p&gt;
&lt;p&gt;The post rightly warns that storing authentication tokens in &lt;code&gt;localStorage&lt;/code&gt; magnifies the blast radius of any XSS vulnerability. For cookie-based sessions, &lt;code&gt;Secure&lt;/code&gt; and &lt;code&gt;HttpOnly&lt;/code&gt; flags provide important defense-in-depth, though applications still have to address CSRF, XSS, and session expiration at the architectural level. When JWTs are genuinely needed, RFC 8725 (JWT Best Current Practices) requires restricting accepted algorithms, verifying signatures, and validating claims like issuer and audience; alternatives like PASETO eliminate several cryptographic footguns by design, though they still don&amp;rsquo;t solve stateful session revocation on their own. For most web applications, the pragmatic default remains starting with your framework&amp;rsquo;s built-in session middleware backed by &lt;code&gt;Secure&lt;/code&gt;, &lt;code&gt;HttpOnly&lt;/code&gt; cookies and a fast store like Redis or Postgres, reaching for bearer tokens only when cross-service trust boundaries actually call for them.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!N2N1!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5edb76e4-d060-48d2-bd73-afe04f1cff5a_1284x1536.jpeg" alt="The AI Agent Stack, Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!wI2g!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F148840a3-d7df-4308-adad-c227f4d280e8_2360x2960.png" alt="Understanding Git Reset Modes"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!CKOS!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8d2521b0-1dd8-4b28-afbd-34f2bb44ee50_2360x2960.png" alt="How NAT Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!HMwY!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6af9e24b-9be2-4a45-9f81-14ec6f4330ca_2484x3002.png" alt="SLMs vs. LLMs, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Z5zI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5233378c-3c59-40b1-9de2-6515b9d3e928_2484x3002.png" alt="Single Agent vs. Multi-Agent Architecture"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U8C6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b849efb-0467-4a5d-b735-f2296b125e9f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=U8lGbSaCCYI" rel="noopener noreferrer"&gt;Running LLMs Locally for Learning and Privacy&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This ByteByteGo video explains why running LLMs on your own machine is great for learning, experimentation, and privacy: sensitive data never leaves your device, you can work offline, and costs stay completely predictable. It also surveys the local LLM ecosystem—from Ollama, LM Studio, and MLX-LM for personal workflows to vLLM and SGLang for high-throughput inference serving.&lt;/p&gt;

&lt;/blockquote&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 #117</title><link>https://miti99.com/en/post/2026/07/05/</link><pubDate>Sun, 05 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #117.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="should-you-normalize-rgb-values-by-255-or-256"&gt;&lt;a href="https://30fps.net/pages/255-vs-256-division/" rel="noopener noreferrer"&gt;Should you normalize RGB values by 255 or 256?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pekka Väänänen dissects a deceptively small question that sparks endless debate in image processing: when converting 8-bit RGB color values to floating point, should you divide by 255, or add half a step and divide by 256? The familiar &lt;code&gt;img / 255.0&lt;/code&gt; maps 0 to 0.0 and 255 to 1.0, preserving exact black and exact white, which is convenient for almost all downstream shader and image code. The alternative &lt;code&gt;(img + 0.5) / 256.0&lt;/code&gt; places each sample at the midpoint of a quantization bucket—cleaner from a signal-quantization standpoint and yielding slightly lower theoretical reconstruction error, but only when you control both the encoding and decoding sides of the pipeline.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s pragmatic verdict: for images coming from the outside world, divide by 255. The usual arguments against 255—that the two endpoint buckets are half-width, that floats don&amp;rsquo;t represent thirds or fifths of 255 exact to the last bit, or that a tiny sliver of precision is wasted—are negligible in practice. Conversely, dividing by 256 on images that were quantized under the standard 255 convention introduces bias and hardcodes an 8-bit assumption into your code. The real bug to fear is mixing one convention&amp;rsquo;s encoder with the other&amp;rsquo;s decoder. Only consider dividing by 256 inside a closed system where you control the entire read/write pipeline, don&amp;rsquo;t need 0 to map to 0.0, and every component agrees on the exact same convention.&lt;/p&gt;
&lt;h2 id="jira-is-turing-complete"&gt;&lt;a href="https://seriot.ch/computation/jira.html" rel="noopener noreferrer"&gt;Jira is Turing-Complete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Seriot turns a classic office joke about Jira into a formal proof: Jira Automation can simulate a Minsky register machine, a computational model known to be Turing-complete. In the author&amp;rsquo;s construction, each register is represented by the count of linked issues of a specific type (such as Bug and Task); the instruction pointer is the current status of an Epic; the program table is the set of automation rules; and each clock cycle is a status transition triggered by an automation rule. Using only operations that create, delete, and check linked issues, Jira can express &lt;code&gt;INC&lt;/code&gt;, &lt;code&gt;DEC&lt;/code&gt;, and conditional branching.&lt;/p&gt;
&lt;p&gt;The minimal example is addition: transferring the count of Bugs in register A into Tasks in register B using statuses like &lt;code&gt;TODO&lt;/code&gt;, &lt;code&gt;DEV&lt;/code&gt;, and &lt;code&gt;PROD&lt;/code&gt;. While A still has a Bug, a rule deletes one Bug and transitions to a state that increments B; once A hits zero, it transitions to the halt state. Seriot also uses an issue-type conversion action—which effectively fuses a decrement and an increment into a single step—to compress a Fibonacci program down to three statuses across three registers. The program runs until it hits Jira Cloud&amp;rsquo;s automation chain-depth limit and requires an operator to re-trigger it. Quota limits like that don&amp;rsquo;t invalidate the proof, since every physical computer is finite too. The takeaway isn&amp;rsquo;t that you should write software in Jira, but that complex workflow automations genuinely are programs—complete with state, memory, branches, and loops.&lt;/p&gt;
&lt;h2 id="usb-for-software-developers-an-introduction-to-writing-userspace-usb-drivers"&gt;&lt;a href="https://werwolv.net/posts/usb_for_sw_devs/" rel="noopener noreferrer"&gt;USB for Software Developers: An introduction to writing userspace USB drivers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WerWolv writes an approachable introduction to USB for software developers who want to talk to hardware devices without diving into electrical signaling or writing kernel modules. The running example is an Android phone in bootloader mode, since the Fastboot protocol is simple, well documented, and typically doesn&amp;rsquo;t have an OS kernel driver claiming the interface automatically. The guide starts with &lt;code&gt;lsusb&lt;/code&gt; to inspect the &lt;code&gt;VID&lt;/code&gt;, &lt;code&gt;PID&lt;/code&gt;, device class, and bound drivers, before moving to &lt;code&gt;libusb&lt;/code&gt; to discover and open the device directly from userspace.&lt;/p&gt;
&lt;p&gt;The most valuable part is how the author connects each USB concept directly to working code. During enumeration, the host uses control endpoint &lt;code&gt;0x00&lt;/code&gt; to send standard requests like &lt;code&gt;GET_STATUS&lt;/code&gt; and &lt;code&gt;GET_DESCRIPTOR&lt;/code&gt;, reading descriptors to learn what configurations, interfaces, and endpoints the device exposes. Endpoints can be thought of like communication ports, except USB is strictly host-driven—a device never sends data unprompted. The post explains the four transfer types (Control, Bulk, Interrupt, Isochronous) and notes that &lt;code&gt;IN&lt;/code&gt; and &lt;code&gt;OUT&lt;/code&gt; directions are always defined from the host&amp;rsquo;s perspective. Finally, the sample program sends a Fastboot &lt;code&gt;getvar:version&lt;/code&gt; command over a Bulk OUT endpoint and reads back &lt;code&gt;OKAY0.4&lt;/code&gt; from the Bulk IN endpoint. The takeaway: for a device with a documented protocol, writing a userspace driver with &lt;code&gt;libusb&lt;/code&gt; feels much closer to socket programming than intimidating kernel development.&lt;/p&gt;
&lt;h2 id="everything-you-need-to-know-about-sourcemaps"&gt;&lt;a href="https://neciudan.dev/everything-you-need-to-know-about-sourcemaps" rel="noopener noreferrer"&gt;Everything you need to know about Sourcemaps&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neciu Dan examines sourcemaps from both angles: as an indispensable debugging tool and as a source-code exposure risk. After bundling, browsers execute concatenated, minified, and mangled code, making an error like &lt;code&gt;bundle.min.js:1:48211&lt;/code&gt; nearly useless. A sourcemap is a JSON file mapping positions in the minified output back to the original file, line, column, and identifier names so stack traces become readable again. Yet those very fields—&lt;code&gt;sources&lt;/code&gt;, &lt;code&gt;names&lt;/code&gt;, &lt;code&gt;mappings&lt;/code&gt;, and especially &lt;code&gt;sourcesContent&lt;/code&gt;—can expose directory structures, module names, comments, internal API endpoints, and even the entire original source code if &lt;code&gt;.map&lt;/code&gt; files are left publicly accessible.&lt;/p&gt;
&lt;p&gt;The core lesson is that minification is not a security boundary. When a production bundle points to a sourcemap via &lt;code&gt;sourceMappingURL&lt;/code&gt; or the &lt;code&gt;SourceMap&lt;/code&gt; HTTP header, anyone with DevTools or &lt;code&gt;curl&lt;/code&gt; can download it if the server permits access. The author cites real-world incidents—including Apple&amp;rsquo;s web App Store in 2025 and version 2.1.88 of the &lt;code&gt;@anthropic-ai/claude-code&lt;/code&gt; npm package shipping with a nearly 60 MB &lt;code&gt;cli.js.map&lt;/code&gt; file—to show that leaks are usually simple build or packaging misconfigurations rather than sophisticated attacks. Mitigations include disabling sourcemaps in production when unneeded, uploading sourcemaps privately to Sentry (noting that &amp;ldquo;hidden&amp;rdquo; sourcemaps only omit the reference comment without blocking direct URL access), blocking &lt;code&gt;.map&lt;/code&gt; requests at the web server or CDN, stripping &lt;code&gt;.map&lt;/code&gt; files from build artifacts and npm tarballs, and adding CI/CD checks (such as inspecting &lt;code&gt;npm pack&lt;/code&gt; output) to catch accidental sourcemap publishing.&lt;/p&gt;
&lt;h2 id="extended-statistics-in-postgres"&gt;&lt;a href="https://www.valerieparhamthompson.com/posts/extended-statistics-postgres/" rel="noopener noreferrer"&gt;Extended Statistics in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Valerie Parham-Thompson explains how extended statistics help the Postgres query planner make far more accurate row estimates when columns are correlated in ways default statistics cannot see. The planner relies on internal catalog tables like &lt;code&gt;pg_class&lt;/code&gt; and &lt;code&gt;pg_stats&lt;/code&gt; to estimate row counts, distinct values, histograms, and most common values, but those statistics are collected per column and implicitly assume filter conditions are independent. For instance, &lt;code&gt;zip='91605'&lt;/code&gt; almost entirely implies &lt;code&gt;state='CA'&lt;/code&gt;, yet by default the planner multiplies the two selectivities as if they were independent variables, severely underestimating row counts and picking a poor execution plan.&lt;/p&gt;
&lt;p&gt;The post walks through all three kinds of extended statistics. The &lt;code&gt;dependencies&lt;/code&gt; type captures functional dependencies between columns, such as a ZIP code largely determining the state; after running &lt;code&gt;CREATE STATISTICS ... (dependencies)&lt;/code&gt; and &lt;code&gt;ANALYZE&lt;/code&gt;, the planner&amp;rsquo;s row estimate jumps much closer to reality. The &lt;code&gt;mcv&lt;/code&gt; (most-common values) type tracks frequent value combinations across multiple columns, helping multi-column &lt;code&gt;WHERE&lt;/code&gt; filters like category plus subcategory. The &lt;code&gt;ndistinct&lt;/code&gt; type helps the planner estimate group counts for multi-column &lt;code&gt;GROUP BY&lt;/code&gt; clauses instead of naively multiplying each column&amp;rsquo;s distinct count. The practical takeaway: when you know your schema has correlated columns, teach the planner with extended statistics instead of reflexively reaching for another index.&lt;/p&gt;
&lt;h2 id="finding-a-needle-in-a-4-gb-haystack-from-075-gbs-to-49-gbs-in-go"&gt;&lt;a href="https://segflow.github.io/post/fast-file-search-go/" rel="noopener noreferrer"&gt;Finding a needle in a 4 GB haystack: from 0.75 GB/s to 49 GB/s in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Assel Meher uses a deliberately trivial problem to dissect file reading and scanning performance in Go: finding a single non-zero &lt;code&gt;int64&lt;/code&gt; near the end of a 4 GiB file filled almost entirely with zeros. With no parsing or complex algorithms in the way, the benchmarks expose the true cost of each layer: the Go runtime, standard library, syscalls, page cache, memory bandwidth, &lt;code&gt;mmap&lt;/code&gt;, &lt;code&gt;pread&lt;/code&gt;, multithreading, and SIMD. The baseline—calling &lt;code&gt;os.ReadFile&lt;/code&gt; and ranging byte by byte—hits just ~0.75 GB/s because it allocates and copies 4 GiB before inspecting one byte at a time; &lt;code&gt;bufio.ReadByte&lt;/code&gt; fares no better due to per-byte function call overhead.&lt;/p&gt;
&lt;p&gt;The first major leap comes from eliminating per-byte work: reading in 1 MiB chunks and scanning as &lt;code&gt;uint64&lt;/code&gt; words immediately crosses 13 GB/s. &lt;code&gt;mmap&lt;/code&gt; doesn&amp;rsquo;t automatically win because, while it avoids copying into userspace buffers, touching every page triggers over a million minor page faults. Parallelism helps further, and parallel &lt;code&gt;pread&lt;/code&gt; handily beats parallel &lt;code&gt;mmap&lt;/code&gt;—which plateaus around 28 GB/s due to page-fault lock contention—because sequential block copies are cheaper than massive concurrent page faults. Adding SIMD via AVX2 or Go 1.26&amp;rsquo;s &lt;code&gt;simd/archsimd&lt;/code&gt; package makes the inner scan loop nearly free, at which point memory bandwidth, read strategy, and concurrency become the real bottlenecks. On a Ryzen 5 9600X under WSL2 with a warm page cache, parallel &lt;code&gt;pread&lt;/code&gt; plus SIMD reaches ~49 GB/s; going any faster requires reading less data or buying faster hardware.&lt;/p&gt;
&lt;h2 id="http-caching-a-refresher"&gt;&lt;a href="https://danburzo.ro/http-caching-refresher/" rel="noopener noreferrer"&gt;HTTP caching, a refresher&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Cătălin Burzo revisits RFC 9111 to organize the essential concepts of modern HTTP caching. He reminds readers that &amp;ldquo;the cache&amp;rdquo; isn&amp;rsquo;t just the browser&amp;rsquo;s private cache, but also shared caches like proxies, CDNs, and Varnish sitting between clients and origin servers. At the center is the &lt;code&gt;Cache-Control&lt;/code&gt; header: directives like &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;no-cache&lt;/code&gt;, &lt;code&gt;no-store&lt;/code&gt;, &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;must-revalidate&lt;/code&gt;, &lt;code&gt;stale-while-revalidate&lt;/code&gt;, and &lt;code&gt;stale-if-error&lt;/code&gt; govern not only whether a response may be stored, but also how long it stays &amp;ldquo;fresh&amp;rdquo; (based on age versus &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;Expires&lt;/code&gt;, or heuristics from &lt;code&gt;Last-Modified&lt;/code&gt;), when it must be revalidated with the origin, and whether a shared cache is allowed to store responses to requests carrying an &lt;code&gt;Authorization&lt;/code&gt; header.&lt;/p&gt;
&lt;p&gt;Burzo also clarifies several common points of confusion. A stale response isn&amp;rsquo;t necessarily discarded: a cache can send a conditional request using &lt;code&gt;If-None-Match&lt;/code&gt; (with an &lt;code&gt;ETag&lt;/code&gt;) or &lt;code&gt;If-Modified-Since&lt;/code&gt; (with &lt;code&gt;Last-Modified&lt;/code&gt;) to receive a &lt;code&gt;304 Not Modified&lt;/code&gt; without re-downloading the body. The &lt;code&gt;Vary&lt;/code&gt; header splits the cache key across request headers like &lt;code&gt;Accept-Language&lt;/code&gt;, which can tank hit rates if header values are too diverse, while &lt;code&gt;No-Vary-Search&lt;/code&gt; solves the inverse problem by ignoring query parameters that don&amp;rsquo;t affect response content. The final section compares normal reloads against hard reloads in browsers, explains the role of &lt;code&gt;immutable&lt;/code&gt;, and warns that misusing &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, or &lt;code&gt;must-revalidate&lt;/code&gt; can trick shared caches into storing authenticated responses—so reach for &lt;code&gt;private&lt;/code&gt; whenever a response belongs strictly to one user.&lt;/p&gt;
&lt;h2 id="how-to-use-ss-as-a-replacement-for-netstat-to-view-ipv4-sockets"&gt;&lt;a href="https://oneuptime.com/blog/post/2026-03-20-ss-replacement-netstat-ipv4-sockets/view" rel="noopener noreferrer"&gt;How to Use ss as a Replacement for netstat to View IPv4 Sockets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nawaz Dhandala introduces &lt;code&gt;ss&lt;/code&gt; as the modern replacement for the deprecated &lt;code&gt;netstat&lt;/code&gt; utility when inspecting sockets on Linux. Because &lt;code&gt;ss&lt;/code&gt; queries socket state directly from the kernel via netlink rather than parsing &lt;code&gt;/proc&lt;/code&gt; files, it is significantly faster, especially on busy servers handling thousands of connections. Focusing on IPv4 with the &lt;code&gt;-4&lt;/code&gt; flag, the post walks through everyday command patterns: listing all TCP, UDP, and raw sockets, viewing active TCP connections, checking listening ports, displaying process names and PIDs (when run with privileges), filtering by state such as &lt;code&gt;state established&lt;/code&gt;, filtering by port with expressions like &lt;code&gt;dport = :443&lt;/code&gt;, filtering by address like &lt;code&gt;src 192.168.1.100&lt;/code&gt;, and viewing summary statistics with &lt;code&gt;ss -s&lt;/code&gt;. The flags &lt;code&gt;-t&lt;/code&gt;, &lt;code&gt;-u&lt;/code&gt;, &lt;code&gt;-l&lt;/code&gt;, &lt;code&gt;-n&lt;/code&gt;, and &lt;code&gt;-p&lt;/code&gt; map cleanly to TCP, UDP, listening sockets, numeric output, and process info.&lt;/p&gt;
&lt;p&gt;The handiest section is a side-by-side translation table from &lt;code&gt;netstat&lt;/code&gt; to &lt;code&gt;ss&lt;/code&gt;: muscle-memory commands like &lt;code&gt;netstat -an&lt;/code&gt;, &lt;code&gt;netstat -tnp&lt;/code&gt;, and &lt;code&gt;netstat -tlnp&lt;/code&gt; translate directly to &lt;code&gt;ss -an&lt;/code&gt;, &lt;code&gt;ss -tnp&lt;/code&gt;, and &lt;code&gt;ss -tlnp&lt;/code&gt;. For day-to-day troubleshooting, &lt;code&gt;ss -4tulnp&lt;/code&gt; is the most compact command to see all listening IPv4 TCP and UDP sockets along with their owning processes, while &lt;code&gt;ss -4tn state established&lt;/code&gt; is ideal for inspecting active IPv4 TCP connections. It serves as a concise, practical cheat sheet for Linux operations.&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 #116</title><link>https://miti99.com/en/post/2026/07/04/</link><pubDate>Sat, 04 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #116.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="8-myths-on-software-engineering-and-ai"&gt;&lt;a href="https://newsletter.getdx.com/p/8-myths-on-software-engineering-and" rel="noopener noreferrer"&gt;8 myths on software engineering and AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck introduces the paper &amp;ldquo;8 Myths on Software Engineering and GenAI,&amp;rdquo; which he co-authored, grouping eight common misconceptions about AI in software engineering into three themes: how developers actually spend their time, how to measure AI&amp;rsquo;s impact, and how AI is adopted inside real organizations. A 2025 study found that developers spend only about 14% of their time writing code, with the rest going to design, meetings, code review, and coordination. Consequently, code generation tools act on a relatively small lever, and speeding up coding easily shifts the bottleneck downstream into code review. Measuring productivity by lines of code—including AI-generated lines—only inflates the review burden; PR throughput is better, but still needs to sit inside a balanced set of metrics.&lt;/p&gt;
&lt;p&gt;Research findings on AI coding tools vary widely: some studies show clear speedups, others are neutral, and one study found experienced developers actually took 18% longer when using AI. Task type, developer experience, and prompting skill all shape the outcome. On the adoption side, 80% of developers use AI tools, yet only 29% trust their accuracy. The overarching takeaway is that AI&amp;rsquo;s impact depends far more on the work system surrounding developers than on the model itself: organizations need to build trust, workflows, guardrails, and system-level measurement rather than simply buying licenses and waiting for productivity to climb on its own.&lt;/p&gt;
&lt;h2 id="you-don"&gt;&lt;a href="https://blog.tjll.net/you-dont-love-systemd-timers-enough/" rel="noopener noreferrer"&gt;You Don&amp;rsquo;t Love systemd Timers Enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that while we still call every scheduled task a &amp;ldquo;cron job,&amp;rdquo; in 2026 there is rarely a reason to use actual &lt;code&gt;cron&lt;/code&gt;. A systemd timer is a unit that schedules another unit—typically a matching &lt;code&gt;.service&lt;/code&gt;—cleanly separating &amp;ldquo;when to run&amp;rdquo; from &amp;ldquo;what to run.&amp;rdquo; That separation solves classic &lt;code&gt;cron&lt;/code&gt; headaches: unpredictable &lt;code&gt;$PATH&lt;/code&gt; environments, swallowed stdout/stderr, hard-to-audit run history, and cryptic schedule syntax. Output goes straight into the journal, while &lt;code&gt;systemctl status&lt;/code&gt; and &lt;code&gt;systemctl list-timers&lt;/code&gt; show both the last run and the next scheduled trigger. The post also notes that &lt;code&gt;ExecStart=&lt;/code&gt; does not run inside a shell by default and does not inherit your interactive shell environment, so unit files should be written explicitly rather than treated like shell scripts—taking advantage of built-in directives like &lt;code&gt;ExecCondition=&lt;/code&gt;, &lt;code&gt;OnFailure=&lt;/code&gt;, and &lt;code&gt;Restart=&lt;/code&gt; instead of reinventing them by hand.&lt;/p&gt;
&lt;p&gt;The most valuable part highlights capabilities that go well beyond traditional &lt;code&gt;cron&lt;/code&gt;. The &lt;code&gt;systemd-analyze calendar&lt;/code&gt; command lets you validate and test schedule expressions before deploying them. Alongside wall-clock schedules via &lt;code&gt;OnCalendar=&lt;/code&gt;, timers support monotonic schedules like &lt;code&gt;OnBootSec=&lt;/code&gt; and &lt;code&gt;OnUnitActiveSec=&lt;/code&gt;—running relative to system boot or the unit&amp;rsquo;s last activation, which often matches operational intent much better than fixed minute or hour intervals. Options like &lt;code&gt;WakeSystem=&lt;/code&gt;, &lt;code&gt;Persistent=&lt;/code&gt;, &lt;code&gt;RandomizedDelaySec=&lt;/code&gt;, &lt;code&gt;FixedRandomDelay=&lt;/code&gt;, and &lt;code&gt;RandomizedOffsetSec=&lt;/code&gt; can wake a sleeping machine, catch up on missed runs after downtime, and prevent thundering herds across fleets. In short, systemd timers express operational schedules far more clearly than &lt;code&gt;cron&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="life-is-too-short-for-a-slow-terminal"&gt;&lt;a href="https://mijndertstuij.nl/posts/life-is-too-short-for-a-slow-terminal/" rel="noopener noreferrer"&gt;Life is too short for a slow terminal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mijndert Stuij writes about keeping his terminal fast because he lives in it all day, where every tiny delay when opening a tab, typing a command, or hitting Tab to autocomplete gets multiplied hundreds of times. His zsh shell starts in roughly 30ms—not thanks to a massive optimization project, but through a habit of keeping the configuration minimal. The biggest wins come from what isn&amp;rsquo;t there: no oh-my-zsh, no plugin manager, just sourcing the three plugins he actually needs directly. Because &lt;code&gt;compinit&lt;/code&gt; is a common startup bottleneck, he caches &lt;code&gt;.zcompdump&lt;/code&gt; so a full check runs only about once a day, while every other shell launch uses &lt;code&gt;compinit -C&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For heavy tools like &lt;code&gt;nvm&lt;/code&gt; or &lt;code&gt;kubectl&lt;/code&gt; completions, he uses lazy-loading: wrapping them in stub functions that only load the real initialization code the first time the command is invoked. Any tool that tells you to drop &lt;code&gt;eval &amp;quot;$(tool init zsh)&amp;quot;&lt;/code&gt; into &lt;code&gt;.zshrc&lt;/code&gt; is a prime candidate for lazy-loading. Prompts should also avoid running synchronous &lt;code&gt;git status&lt;/code&gt; checks inside large repositories; an async prompt like &lt;code&gt;pure&lt;/code&gt; renders immediately and fills in Git status in the background. Finally, he advises measuring instead of guessing, distinguishing between startup time, prompt latency, and input latency: use &lt;code&gt;time zsh -i -c exit&lt;/code&gt;, &lt;code&gt;hyperfine&lt;/code&gt;, &lt;code&gt;zprof&lt;/code&gt;, or startup traces to find the slowest culprit and fix bottlenecks one by one. By his rule of thumb, under 100ms is fine and under 50ms is great.&lt;/p&gt;
&lt;h2 id="opencodereview"&gt;&lt;a href="https://github.com/alibaba/open-code-review" rel="noopener noreferrer"&gt;OpenCodeReview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;OpenCodeReview is Alibaba&amp;rsquo;s open-source CLI tool for AI-powered code review. Born out of an internal review assistant that served tens of thousands of developers over two years, the project is now open to the community and works out of the box with any OpenAI- or Anthropic-compatible model endpoint. Rather than feeding a raw diff to a model and getting generic remarks back, the tool reads the Git diff, lets an agent read full files, search the codebase, and inspect related changed files, and then emits precise line-by-line review comments. Beyond diff-based reviews, the &lt;code&gt;ocr scan&lt;/code&gt; command can audit entire files or directories when exploring an unfamiliar codebase.&lt;/p&gt;
&lt;p&gt;A notable design choice is its hybrid architecture combining deterministic pipelines with agentic reasoning. Steps that cannot afford to be flaky—file selection, grouping related files, matching rules to files, and anchoring line comments—are handled by a strictly constrained pipeline; the agent focuses solely on dynamic reasoning like gathering context and calling tools, guided by review-tuned prompts and toolsets. Built-in rules cover issues like NPEs, thread safety, XSS, and SQL injection. Benchmarks built from 200 real pull requests show that compared to a general-purpose coding agent running the same model, OpenCodeReview achieves higher precision and F1 score while using roughly 1/9th the tokens, at the cost of lower recall—a deliberate trade-off to keep false positives down.&lt;/p&gt;
&lt;h2 id="golang-code-review-notes-ii"&gt;&lt;a href="https://www.elttam.com/blog/golang-code-review-notes-ii" rel="noopener noreferrer"&gt;Golang code review notes II&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zoltan Madarassy and Alex Brown continue their security-focused Go code review notes. Their main premise is that automated scanners and AI assistants now catch most obvious bugs, leaving the truly dangerous issues hiding in subtle corners of the language and standard library that reviewers must actively know to look for. The post starts with a few positive ecosystem improvements: &lt;code&gt;os.Root&lt;/code&gt; in Go 1.24 helps prevent path traversal vulnerabilities, and Go 1.26 updates several cryptographic functions to draw from a secure internal randomness source automatically, though &lt;code&gt;math/rand&lt;/code&gt; remains unsuitable for cryptographic use.&lt;/p&gt;
&lt;p&gt;The bulk of the post focuses on footguns that still slip past review. Integer overflows happen silently—for example, casting a length to a narrower type like &lt;code&gt;uint32(len(s))&lt;/code&gt;—which can corrupt framing boundaries in serialization libraries. &lt;code&gt;httputil.ReverseProxy.Director&lt;/code&gt; is vulnerable to hop-by-hop header abuse, so code should migrate to &lt;code&gt;Rewrite&lt;/code&gt;, which runs after those headers are stripped. Shallow pointer copies in &lt;code&gt;net/url&lt;/code&gt; can lead to shared-state mutation and race conditions; null bytes crossing CGO or C library boundaries can bypass validation checks; and &lt;code&gt;encoding/json&lt;/code&gt; can silently skip a custom marshaller if the method uses a pointer receiver while the struct is passed by value. JSON APIs also aren&amp;rsquo;t automatically immune to CSRF unless &lt;code&gt;Content-Type&lt;/code&gt;, &lt;code&gt;SameSite&lt;/code&gt; cookies, and request origins are properly validated. The authors also release a set of Semgrep rules to catch several of these patterns automatically.&lt;/p&gt;
&lt;h2 id="thoughts-on-starting-new-projects-with-llm-agents"&gt;&lt;a href="https://eli.thegreenplace.net/2026/thoughts-on-starting-new-projects-with-llm-agents/" rel="noopener noreferrer"&gt;Thoughts on starting new projects with LLM agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eli Bendersky shares his experience using LLM agents to build &lt;code&gt;watgo&lt;/code&gt;, a new Go project, from scratch. He starts by iterating with the agent on the design and API, saving the result as a committed Markdown file in the repository that both human and agent follow as a shared blueprint. From there, he asks the agent to implement small changelists (CLs) in a logical sequence, reviews each one in VSCode&amp;rsquo;s diff view, makes manual edits where needed, and commits the changes himself. When the agent produces a diff that grows too large, the pragmatic move is to commit at an acceptable intermediate state and ask for follow-up refactorings in separate CLs; if a whole direction turns out wrong, the commit chain is still easy to revert.&lt;/p&gt;
&lt;p&gt;His central message is that humans must stay firmly in the loop on any project meant for long-term maintenance. Vibe coding works fine for prototypes or throwaway scripts, but on a serious project, the author must understand, review, and steer every design decision. He stresses small CLs and a solid testing strategy, warning against letting an agent write both the implementation and the tests in one go, where it can easily bake its own bugs into the test expectations. He also finds Go exceptionally well suited for agentic coding thanks to its stability, minimal syntactic redundancy, rich standard library, uniform formatting, and explicit error handling—when human effort shifts from writing code to reading it, readability becomes a massive advantage. Finally, he cautions junior developers to be careful about leaning too heavily on LLMs while still building foundational skills.&lt;/p&gt;
&lt;h2 id="the-history-of-pets-vs-cattle-and-how-to-use-the-analogy-properly"&gt;&lt;a href="https://cloudscaling.com/blog/cloud-computing/the-history-of-pets-vs-cattle/" rel="noopener noreferrer"&gt;The History of Pets vs Cattle and How to Use the Analogy Properly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Randy Bias recounts the origin and intended meaning of the &amp;ldquo;pets vs. cattle&amp;rdquo; analogy in cloud infrastructure. He adapted the metaphor from a presentation on scaling SQL Server, reframing it for cloud computing to contrast the irreplaceability of a &amp;ldquo;pet&amp;rdquo; with the fungibility of &amp;ldquo;cattle.&amp;rdquo; A &amp;ldquo;pet&amp;rdquo; is a server or pair of servers treated as indispensable—typically built and cared for by hand, where a failure sends the whole team scrambling to nurse it back to health. &amp;ldquo;Cattle&amp;rdquo; are fleets of three or more machines provisioned automatically and designed for failure, so losing a node or two is handled automatically by the system without human intervention. The analogy caught on because it captured the shift from traditional sysadmin practices to cloud-native architecture in a single image.&lt;/p&gt;
&lt;p&gt;Bias also warns that misusing the analogy strips away its original lesson. A prime example was Kubernetes originally naming StatefulSets &amp;ldquo;Pet Sets&amp;rdquo;: the stateful distributed systems cited as examples—Cassandra, Kafka, MongoDB—are actually architected as &amp;ldquo;cattle,&amp;rdquo; since they handle node failure through horizontal scale-out. Defining a &amp;ldquo;pet&amp;rdquo; as any system that needs special handling, rather than a system that isn&amp;rsquo;t allowed to fail, blurs the distinction between legacy operations and cloud-native design. The core of the analogy is server replaceability and system-level fault tolerance, not whether a workload happens to be stateful.&lt;/p&gt;
&lt;h2 id="every-byte-matters"&gt;&lt;a href="https://fzakaria.com/2026/06/01/every-byte-matters" rel="noopener noreferrer"&gt;Every byte matters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria reminds us that performance isn&amp;rsquo;t just about Big-O complexity. Even inside a simple linear loop, data size and memory layout make a massive difference because CPUs fetch memory in cache lines, typically 64 bytes at a time. If a struct is large but a loop only inspects a single small field like &lt;code&gt;is_alive&lt;/code&gt;, an array-of-structs layout drags dozens of unused bytes into the cache on every read. Flipping to a struct-of-arrays layout packs that single field into contiguous memory so every cache line fetch serves many more elements; in the author&amp;rsquo;s benchmark, this yielded up to a 30x speedup when the struct size reached 1KiB.&lt;/p&gt;
&lt;p&gt;The post also explains why working set size is critical for random access patterns. During sequential scans, the CPU hardware prefetcher can predict upcoming addresses and hide memory latency. With hash maps, trees, graphs, or pointer-heavy structures, however, the next address is unpredictable, meaning the working set must fit inside CPU cache to avoid stalling on main memory. Simply doubling a struct from 64B to 128B pushes the exact same number of elements down into a slower cache tier: at 512 elements, 64B structs fit inside L1d at ~3 ns latency, whereas 128B structs spill into L2 at ~11 ns. The practical lesson is that every byte on a hot path carries a cost, and understanding struct sizes, cache lines, and working sets often yields far bigger wins than algorithmic analysis alone.&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 #103</title><link>https://miti99.com/en/post/2026/05/23/</link><pubDate>Sat, 23 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #103.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="drunk-post-things-i"&gt;&lt;a href="https://luminousmen.substack.com/p/drunk-post-things-ive-learned-as" rel="noopener noreferrer"&gt;Drunk Post: Things I&amp;rsquo;ve Learned as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post preserves a famous r/ExperiencedDevs thread where a data engineer with 10 years of experience got &amp;ldquo;a little tipsy&amp;rdquo; and wrote down every career lesson he had learned. The original account has since been deleted, but its rare candor keeps the post widely shared. On career growth, the author argues that switching companies is the most effective way to get promoted, job titles matter less than what you actually accomplish, and the closer you are to the product and revenue, the more valued you are — regardless of how technically complex your work is.&lt;/p&gt;
&lt;p&gt;On the technical side, every domain has only about 10–20 core principles, and the fundamentals change very slowly even as tools churn constantly. Good code is code a junior engineer can read and understand, and the best code is code you never had to write at all. Writing documentation is the most underrated skill, right alongside writing proposals for change. For newcomers, SQL is the highest-ROI language; testing is essential, but TDD is overly worshiped. Good engineers know best practices, while senior engineers know when to break them. What the author is proudest of is not any grand system he built, but helping others do better work. The archivist agrees with nearly all of it, except for the author&amp;rsquo;s preference for dynamic languages.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-to-code"&gt;&lt;a href="https://www.chrismdp.com/coding-with-ai-april-2026/" rel="noopener noreferrer"&gt;How I Use AI to Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Parsons argues that if you are still tethered to an IDE like Cursor or Copilot, you are a year behind: the best tools have left the editor for the command line, and he recommends Claude Code or Codex CLI. Programming is AI&amp;rsquo;s &amp;ldquo;home turf&amp;rdquo; because code can be executed and verified immediately. He distinguishes &amp;ldquo;vibe coding&amp;rdquo; (never checking the output) from &amp;ldquo;agentic engineering&amp;rdquo; (deliberately deciding which changes require human inspection and which can be entrusted to tests and automated checks). His core message: senior engineers should train AI to write better code rather than manually reviewing every single diff, because the harness surrounding the model matters more than the prompt.&lt;/p&gt;
&lt;p&gt;A good harness consists of persistent instructions in CLAUDE.md or AGENTS.md, skill files that both enforce rules and load extra context on demand, a verification loop so the agent can check its own work, and a feedback loop that feeds lessons back into those three components — with all knowledge stored in a dedicated markdown repository. The author also walks back his earlier advice to specify the entire solution up front, calling that waterfall in disguise: specify the problem, not the solution. Output quality hinges on context volume — too little yields generic results, while too much drowns the model in noise. Once code generation is no longer the bottleneck, verification becomes the new bottleneck, giving teams with strong automated testing and CI/CD foundations a massive advantage.&lt;/p&gt;
&lt;h2 id="email-is-crazy"&gt;&lt;a href="https://samkhawase.com/blog/email-is-crazy/" rel="noopener noreferrer"&gt;Email is crazy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Email is one of the most successful communication technologies in history, yet underneath it lies a patchwork system governed by more than 100 RFCs. Sam Khawase traces the journey of a single message from Alice to Bob: the mail client merely &amp;ldquo;submits&amp;rdquo; the message to a server, the relay server looks up DNS MX records to find the recipient&amp;rsquo;s mail server, and email is fundamentally a store-and-forward queueing system that retries for days rather than a real-time channel. SMTP was born in an era of trust-based academic networks, so the envelope address (&lt;code&gt;MAIL FROM&lt;/code&gt;) and the user-visible &lt;code&gt;From&lt;/code&gt; header are allowed to differ — the root vulnerability that makes phishing and spam possible.&lt;/p&gt;
&lt;p&gt;Instead of replacing SMTP, the industry bolted on three authentication layers: SPF (a list of authorized sending IPs, which breaks when mail is forwarded), DKIM (a cryptographic signature whose public key lives in DNS), and DMARC (requiring the domain in the &lt;code&gt;From&lt;/code&gt; header to align with the domain validated by SPF or DKIM, paired with a policy of none, quarantine, or reject). Messages then pass through each provider&amp;rsquo;s proprietary filtering stack: IP reputation, domain reputation, content analysis, virus scanning, and link checking. Encryption is usually just &amp;ldquo;Opportunistic TLS&amp;rdquo;: if the receiving server doesn&amp;rsquo;t support &lt;code&gt;STARTTLS&lt;/code&gt;, the connection falls back to plaintext (though policies like MTA-STS can enforce TLS), and TLS only encrypts the transport hop rather than end-to-end. Worst of all, an email can be silently dropped into a spam folder without notifying anyone — completely legal under RFC 5321. Even so, email reliably delivers billions of messages every single day.&lt;/p&gt;
&lt;h2 id="high-performance-git"&gt;&lt;a href="https://gitperf.com/" rel="noopener noreferrer"&gt;High Performance Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;High Performance Git&lt;/em&gt; is a book by Ted Nyman about Git&amp;rsquo;s internal architecture and how to operate massive repositories. Rather than teaching a handful of everyday commands, the book views Git as a stack of layers — a content-addressable database, a filesystem cache, a graph walker, and a wire transfer protocol — and analyzes the performance cost of each layer.&lt;/p&gt;
&lt;p&gt;The chapters progress from objects, refs, the index, and history traversal to packfiles, repository maintenance, sparse checkout, partial clone, transfer protocols, operating at scale, troubleshooting, configuration, and data recovery. The book is aimed at anyone who needs Git to stay fast as codebases, histories, and teams grow: build and CI engineers, monorepo maintainers, and developer productivity teams. The entire book is released for free as a PDF under a Creative Commons Attribution-ShareAlike 4.0 license.&lt;/p&gt;
&lt;h2 id="you-can-beat-the-binary-search"&gt;&lt;a href="https://lemire.me/blog/2026/04/27/you-can-beat-the-binary-search/" rel="noopener noreferrer"&gt;You can beat the binary search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire looks for ways to speed up checking whether a value exists in a sorted array of 16-bit integers — a common operation in Roaring Bitmaps, which currently use binary search. He builds on two observations: modern CPUs (both 64-bit ARM and x64) have SIMD instructions that compare eight 16-bit integers at once, and they have substantial memory-level parallelism, so splitting the array into four parts instead of two can be more effective. This leads to the SIMD Quad algorithm: divide the array into blocks of 16 elements, use a quaternary search on the last element of each block to narrow down the candidate block, and then use SIMD to check all 16 elements in that block simultaneously.&lt;/p&gt;
&lt;p&gt;Benchmarks on Apple M4 and Intel Emerald Rapids show SIMD Quad beating binary search across the article&amp;rsquo;s tests: on Intel it is more than 2x faster when the cache is &amp;ldquo;hot,&amp;rdquo; while on Apple it is more than 2x faster when the cache is &amp;ldquo;cold.&amp;rdquo; The &amp;ldquo;quad&amp;rdquo; step makes almost no difference on Apple, but helps significantly on Intel with large arrays and cold caches. The takeaway: classic algorithms weren&amp;rsquo;t designed for hardware with as much parallelism as today&amp;rsquo;s CPUs, leaving plenty of room for performance gains.&lt;/p&gt;
&lt;h2 id="how-might-a-browser-be-developed"&gt;&lt;a href="https://aifoc.us/how-might-a-browser-be-developed/" rel="noopener noreferrer"&gt;How might a browser be developed?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Kinlan asks: how will browsers be developed in the age of AI? Drawing from experiments building browsers with AI and ultra-fast inference chips, he observes that a comprehensive specification paired with an extensive unit test suite acts as an effective guardrail to keep models on track. In the near term, standards bodies could build a &amp;ldquo;reference browser&amp;rdquo; to uncover gaps in specifications and test suites, while browser vendors use AI to implement features from those battle-tested specs. The focus would then shift to writing great specifications, and browsers would differentiate themselves by their vision for the web rather than raw engineering headcount or budget.&lt;/p&gt;
&lt;p&gt;His longer-term vision ventures into sci-fi territory: a browser that synthesizes feature implementations on the fly at runtime from markup, or even purely from expressed intent. For instance, instead of waiting on WebBluetooth support, the browser could generate the code to talk to a heart-rate monitor directly from available hardware documentation. That could eliminate polyfills and make accessibility and localization happen by default, but it also threatens the web&amp;rsquo;s core promise: that the same URL delivers roughly the same experience to everyone, since the experience would now depend on each user&amp;rsquo;s device and local model. Kinlan urges the industry to start thinking seriously about this trajectory now.&lt;/p&gt;
&lt;h2 id="agentic-coding-is-a-trap"&gt;&lt;a href="https://larsfaye.com/articles/agentic-coding-is-a-trap" rel="noopener noreferrer"&gt;Agentic Coding is a Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lars Faye warns against the trend of &amp;ldquo;agentic coding,&amp;rdquo; where AI writes all the code while humans merely plan and orchestrate. The core issue is the &amp;ldquo;supervision paradox,&amp;rdquo; which Anthropic itself has acknowledged: using AI effectively requires supervising it, yet supervision demands the exact programming skills that atrophy when you overuse AI. Another Anthropic study recorded a 47% drop in debugging proficiency. Unlike past transitions such as moving from assembly to FORTRAN, the skill erosion this time is already visible even among veteran engineers, while junior engineers lose the struggle with code that serves as their most important learning mechanism.&lt;/p&gt;
&lt;p&gt;The author argues that AI is accelerating the wrong part of the job: we don&amp;rsquo;t actually need to write code faster, especially code we don&amp;rsquo;t understand, and for many developers, writing code &lt;em&gt;is&lt;/em&gt; how they think and plan. There is also vendor lock-in risk — when Claude goes down, many teams grind to a halt — and unpredictable token costs, whereas human salaries are fixed. His prescription is to demote AI back to an assistant role: use AI for specs and planning, but write 20% to 100% of the code yourself depending on the task, never generate more code than you can review in a single sitting, and never ask AI to do something you haven&amp;rsquo;t done or couldn&amp;rsquo;t do yourself.&lt;/p&gt;
&lt;h2 id="be-the-idiot"&gt;&lt;a href="https://luminousmen.substack.com/p/be-the-idiot" rel="noopener noreferrer"&gt;Be the Idiot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;luminousmen argues that most engineering failures happen because someone was afraid of looking stupid, making clarifying questions not a weakness but a core professional skill. Drawing inspiration from military radio protocols — where the receiver always reads back an order to confirm, not out of incompetence, but because being understood matters more than sounding smart — the author applies two principles to software engineering: repeat critical information across multiple channels such as types, docstrings, and explicit parameter names; and choose unambiguous wording, like &lt;code&gt;timeout_seconds: 30&lt;/code&gt; instead of &lt;code&gt;timeout: short&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author shares four &amp;ldquo;dumb&amp;rdquo; questions that have saved him time and again: what happens when this fails, how do we know it&amp;rsquo;s working properly, what does &amp;ldquo;done&amp;rdquo; look like, and can you show me an example? Phrasing matters too: instead of asking &amp;ldquo;Why are we doing this stupid thing?&amp;rdquo;, ask &amp;ldquo;Is there a specific reason we&amp;rsquo;re using X here?&amp;rdquo; — assuming you&amp;rsquo;re missing context rather than assuming the other person is wrong. About 80% of the time he really was missing context, and the other 20% of the time the question sparked a valuable discussion. After all, the only thing more expensive than looking dumb in a meeting is building the wrong thing because nobody dared to ask.&lt;/p&gt;
&lt;h2 id="3-constraints-before-i-build-anything"&gt;&lt;a href="https://jordanlord.co.uk/blog/3-constraints/" rel="noopener noreferrer"&gt;3 constraints before I build anything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jordan Lord shares three constraints he applies before building any product, distilled from 10 years of product work and multiple failures caused by overcomplication or lack of identity. To him, constraints are a catalyst for creativity because they narrow the option space. The first constraint is &amp;ldquo;one page or nothing&amp;rdquo;: every idea must fit onto a single-page brief that serves as a north star when talking to investors, teammates, or family. If you can&amp;rsquo;t fill one page, the idea isn&amp;rsquo;t ready; if you need more than one page, it&amp;rsquo;s too complicated.&lt;/p&gt;
&lt;p&gt;The second constraint: the core technology must be separable from the product. That could be a method, tool, or library that powers the current product but survives if the product pivots — much like Git was created to support Linux kernel development, or Kubernetes at Google. Products pivot, while core technology compounds in value over time. The third constraint: a defining constraint must shape the product and remain immediately visible to the user, like Minecraft being built entirely out of blocks or IKEA&amp;rsquo;s flat-pack self-assembly furniture. It wards off feature creep and creates unmistakable identity. Any idea that fails to pass all three constraints doesn&amp;rsquo;t get built.&lt;/p&gt;
&lt;h2 id="swissing-a-table"&gt;&lt;a href="https://philpearl.github.io/post/swissing_a_table/" rel="noopener noreferrer"&gt;Swissing a Table&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Pearl explores the Swiss table — the hash table design behind Go&amp;rsquo;s new map implementation — by evolving a simple open-addressed hash table step by step. First, he replaces linear probing with a quadratic-style probing sequence like Go&amp;rsquo;s; next, he groups 8 key–value pairs into a bucket; then he adds 8 control bytes per group (the highest bit marks an empty slot, while the lower 7 bits store a hash fragment); and finally he uses bitwise SWAR tricks on a 64-bit integer to match all 8 control bytes simultaneously instead of checking slots one by one.&lt;/p&gt;
&lt;p&gt;Insertion benchmarks show that a Swiss table doesn&amp;rsquo;t always win: when the table is sparse (around 10–4,000 elements), it is 19–36% slower than the simple table, only pulling ahead as the table fills up and cutting insertion time by up to 71.65% when completely full (32,768 elements). According to the author, the biggest win is that the table can run at high load factors with very little performance degradation — making it primarily a memory-saving optimization rather than a raw speed boost. Go&amp;rsquo;s map currently uses SIMD on amd64 (Intel) but not yet on ARM, so the author saves the SIMD exploration for a follow-up post.&lt;/p&gt;
&lt;h2 id="the-ai-engineering-stack-we-built-internally--on-the-platform-we-ship"&gt;&lt;a href="https://blog.cloudflare.com/internal-ai-engineering-stack/" rel="noopener noreferrer"&gt;The AI engineering stack we built internally — on the platform we ship&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares the internal AI infrastructure they built over 11 months, running entirely on the same products they sell to customers. Over a 30-day window, 3,683 internal users (93% of R&amp;amp;D) used AI coding tools, driving over 20 million requests through AI Gateway and 241 billion tokens; in some weeks, merge request volume nearly doubled the previous quarter&amp;rsquo;s baseline. The architecture spans three layers. The foundation layer uses Cloudflare Access for zero-trust authentication, AI Gateway for routing, cost tracking, and data retention controls, and Workers AI to serve open-weight models at a fraction of proprietary model costs. A single login command configures everything, and routing traffic through an intermediate Worker from day one let them roll out new features later without touching user-side configs.&lt;/p&gt;
&lt;p&gt;The knowledge layer uses Backstage as a service catalog and automatically generates &lt;code&gt;AGENTS.md&lt;/code&gt; files across roughly 3,900 repositories, describing structure, conventions, and boundaries so agents don&amp;rsquo;t have to guess. The execution layer runs an AI Code Reviewer on every merge request: it classifies risk level, dispatches specialized agents, organizes findings by category and severity, and cites specific rules from the Engineering Codex — Cloudflare&amp;rsquo;s internal engineering standards packaged as agent skills. According to Cloudflare, none of the individual pieces are novel; the differentiator is how they are wired together.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7jIm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5632abfa-88b9-4f40-8feb-13b4a7c6e1ce_2484x3002.png" alt="MCP vs Skills, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gUOK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F32f62036-5c89-4686-941e-57d84297de42_2484x3002.png" alt="5 Way to Defend Prompt Injection"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #58</title><link>https://miti99.com/en/post/2025/10/01/</link><pubDate>Wed, 01 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/01/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Today I tried hooking up &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; to the &lt;code&gt;openai/gpt-oss-120b&lt;/code&gt; model on &lt;a href="https://build.nvidia.com/" rel="noopener noreferrer"&gt;NVIDIA NIM&lt;/a&gt;, but it hit some error and produced no output at all. So we&amp;rsquo;re back to &lt;code&gt;qwen3-coder&lt;/code&gt; running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #58.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-software-engineers-make-productive-decisions-without-slowing-the-team-down"&gt;&lt;a href="https://strategizeyourcareer.com/p/how-software-engineers-make-productive-decisions" rel="noopener noreferrer"&gt;How Software Engineers Make Productive Decisions (without slowing the team down)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many development teams slow down simply because they treat every decision as if it were irreversible. Author Fran Soto proposes clearly distinguishing between two types: &amp;ldquo;two-way door&amp;rdquo; decisions (easy to reverse, such as adding an unused field to an API response, gating a change behind a feature flag, or swapping out an internal library) and &amp;ldquo;one-way door&amp;rdquo; decisions (hard or impossible to reverse, such as data migrations, schema changes, security changes, or customer-visible changes that risk data loss). To classify a decision quickly, the article offers three questions: if you&amp;rsquo;re wrong, is the impact unnoticeable, an annoyance, or a disaster; how hard is it to roll back, for instance can you revert within ten minutes using existing alerting; and can you limit the blast radius with a canary, feature flag, or phased rollout?&lt;/p&gt;
&lt;p&gt;For reversible decisions, the author advises time-boxing research to 30–60 minutes and then acting, backed by guardrails: feature flags defaulting to off, small pull requests, tests covering both states, canary checks, solid alerting, and a ten-minute rollback playbook. Heavy caution should be reserved for decisions that are genuinely hard to undo. The core takeaway: when risk is low and the change is reversible, ship with guardrails—that&amp;rsquo;s how you move fast without being reckless.&lt;/p&gt;
&lt;h2 id="why-are-event-driven-systems-hard"&gt;&lt;a href="https://newsletter.scalablethread.com/p/why-event-driven-systems-are-hard" rel="noopener noreferrer"&gt;Why are Event-Driven Systems Hard?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Event-driven architecture decouples services and makes them easier to scale, but comes with five major challenges. First is event schema evolution: when one service adds or changes a field without coordination, downstream consumers can break; the fix is enforcing backward and forward compatibility rules alongside a schema registry acting as a central dictionary for event formats. Second is observability: because processing flows are split across independent services, seeing the full picture during debugging is difficult; the remedy is distributed tracing with a correlation ID—an identifier attached to the initial event and propagated through every processing step to reconstruct a request&amp;rsquo;s journey.&lt;/p&gt;
&lt;p&gt;Third is failure handling: at-least-once delivery prevents message loss when infrastructure hiccups, while a Dead-Letter Queue (DLQ) captures messages that repeatedly fail after a bounded number of retries, preventing infinite error loops and allowing later inspection. Fourth, at-least-once delivery itself means a service may receive the same message multiple times if it crashes before acknowledging completion, so consumers must be idempotent: recording processed event IDs and skipping duplicates (coordinated atomically with business state updates so there is no gap) to avoid bugs like charging a customer twice. Finally, eventual consistency: because data propagates asynchronously across services, both UI and business logic must tolerate systems being temporarily out of sync.&lt;/p&gt;
&lt;h2 id="dev-culture-is-dying-the-curious-developer-is-gone"&gt;&lt;a href="https://dayvster.com/blog/dev-culture-is-dying-the-curious-developer-is-gone/" rel="noopener noreferrer"&gt;Dev Culture Is Dying: The Curious Developer Is Gone&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that developer culture is shifting in a troubling direction. Foundational tools like VLC, Linux, Git, and Docker were born out of curiosity and a desire to solve problems, not for profit or clout. He recalls the 2000s, when programmers stayed up all night tinkering with new technology purely to learn, expecting neither commercial reward nor recognition. Today, attention has shifted to metrics like MRR, ARR, DAU, MAU, SEO rankings, and conversion rates, and many developers chase new frameworks out of pressure to look current rather than genuine interest. Intrinsic motivation has gradually given way to external validation.&lt;/p&gt;
&lt;p&gt;The post also points to an identity crisis: developers define themselves by their tools, becoming a &amp;ldquo;Next.js developer&amp;rdquo; or &amp;ldquo;Rust developer&amp;rdquo; instead of by the problems they solve. The author compares consumer software&amp;rsquo;s shift toward subscription models with creators losing ownership of their craft to corporations or growth metrics, asking whether developers still care about the software they build or only about revenue. The closing call to action is to go back to building curiosity-driven projects—even things that can&amp;rsquo;t be monetized—building for the joy of it and sharing them to inspire others.&lt;/p&gt;
&lt;h2 id="tool-calls-are-expensive-and-finite"&gt;&lt;a href="https://www.reillywood.com/blog/tool-calls-are-expensive-and-finite/" rel="noopener noreferrer"&gt;Tool Calls Are Expensive And Finite&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giving LLMs access to tools enables powerful agents, but Reilly Wood reminds us that a tool call is orders of magnitude more expensive than a normal function call in code, and the number of calls you can make is practically finite. Under the hood, a tool call is still text generation: the model emits structured text (JSON) specifying the tool name and arguments, the harness parses it, executes the real function, and appends the result into the conversation history as a new message before the model reasons further. Every call therefore burns output tokens to generate the invocation and consumes context window space because the result stays in history.&lt;/p&gt;
&lt;p&gt;The author illustrates this with the task of processing 1,000 user IDs via &lt;code&gt;get_user_info()&lt;/code&gt;: a programmer would simply write a loop, whereas an agent would have to make 1,000 individual tool calls and would likely exhaust its context window before finishing. The post suggests three remedies: design agents for tasks that don&amp;rsquo;t require many tool calls, build more flexible tools so each call accomplishes more work, or let the agent write and execute code itself—provided proper security sandboxing is in place.&lt;/p&gt;
&lt;h2 id="keeping-secrets-out-of-logs"&gt;&lt;a href="https://allan.reyes.sh/posts/keeping-secrets-out-of-logs/" rel="noopener noreferrer"&gt;Keeping Secrets Out of Logs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allan Reyes examines why secrets like passwords and tokens keep leaking into logs, stressing that there is no &amp;ldquo;silver bullet&amp;rdquo; that solves the problem completely—only a combination of &amp;ldquo;lead bullets,&amp;rdquo; imperfect defenses that complement one another. Six common causes are: forgetting to remove debug log statements; logging entire large objects such as config structs or HTTP responses; changing the global log level and exposing previously hidden details; secrets embedded in URLs; error monitoring tools capturing local variables; and users accidentally typing their password into the username field.&lt;/p&gt;
&lt;p&gt;Mitigations include funneling logs through a single pipeline; minimizing, redacting, encrypting, or hashing sensitive data; domain primitives that wrap secrets in dedicated types to prevent accidental logging; read-once objects that lock their value after the first read; log formatters that detect and scrub sensitive patterns; unit tests that fail when sensitive data appears; post-write secret scanners; log preprocessors before storage (such as Vector); static-analysis taint checking; and human training. The broader strategy combines laying a solid foundation, understanding data flows, guarding choke points, layering defenses, and preparing incident response and recovery plans for leaks. The author admits this work is never truly finished because new systems can always bypass existing safeguards.&lt;/p&gt;
&lt;h2 id="things-i-believe"&gt;&lt;a href="https://leerob.com/beliefs" rel="noopener noreferrer"&gt;Things I Believe&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson shares the beliefs that shape how he works. First, shipping fast beats a perfect strategy: speed is a superpower, small teams ship faster, and user adoption matters more than merely pushing code. Careers have no ceiling: persistence beats innate talent, steady daily improvements compound over time, and you should take initiative and be helpful. He values truth-seeking—confronting uncomfortable truths, holding strong opinions loosely, and listening to diverse perspectives.&lt;/p&gt;
&lt;p&gt;In his view, communication is the job: clear writing reflects clear thinking, everyone should hone their writing skills, and leaders must clarify ambiguity to prevent misaligned expectations. Leadership doesn&amp;rsquo;t require a title, because influence matters more than position; great leaders both do hands-on work and empower others. Work can also be a hobby when passion is paired with clear boundaries, rather than chasing a mythical &amp;ldquo;work–life balance.&amp;rdquo; Hiring should be uncompromising—only hire candidates who are a &amp;ldquo;hell yes&amp;rdquo; and prioritize growth potential. Finally, always assume good intent, lead with empathy, take criticism objectively, and remember that a working demo is more persuasive than a long memo.&lt;/p&gt;
&lt;h2 id="how-claude-code-is-built"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built" rel="noopener noreferrer"&gt;How Claude Code is Built&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code started as a prototype built by Boris Cherny in September 2024: using Claude to control a terminal via AppleScript, initially just to check what song was playing. Once the team saw the model exploring the filesystem on its own, they realized its product potential. Anthropic began using it internally in November 2024, and within five days half of its engineers were on board; although they considered keeping it internal as a competitive advantage, they released it publicly to advance AI safety research. The team chose TypeScript, React with the Ink framework, the Yoga layout engine, and Bun because these technologies are &amp;ldquo;on distribution&amp;rdquo;—things Claude is already great at—allowing roughly 90% of Claude Code&amp;rsquo;s codebase to be written by Claude Code itself.&lt;/p&gt;
&lt;p&gt;Architecturally, Claude Code is a thin shell around the model with minimal business logic, running directly on the user&amp;rsquo;s machine without virtualization. The most complex part is the permission system: the tool asks for user approval before irreversible actions, supporting one-time or persistent grants with multi-level configuration across project, user, and enterprise scopes. Prototyping speed is equally striking: when building the to-do list feature, the team tried around 20 different prototypes in just two days. Even as the engineering team doubled in size, completed pull requests per engineer rose by 67%—a metric that usually drops during rapid team growth.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e27232c-d4f1-4f4b-94fa-7318d39f6f3e_2360x2960.png" alt="How Java Works"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9bef6181-7eed-45a9-9c7e-abd6864cc62b_2360x2960.png" alt="How Gitflow Branching Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9ffab5bc-5857-4544-8e25-2dbf795e6f85_3000x3900.png" alt="The Life of a Redis Query"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1c2bd03d-66f2-4eb9-8293-7a1d49b9b9b6_2360x2920.png" alt="Cookies vs Sessions"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/26b55058-17ae-453f-8463-4d4e717e489b_2360x2920.png" alt="Access Control Clearly Explained"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/00912640-ad5f-4ec7-aefa-e5eecf67dab0_3000x3900.png" alt="How Git Reset Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/43b73739-a975-42af-999d-8676b1605ed2_3000x3900.png" alt="Apache Kafka Explained (At the high level)"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #53</title><link>https://miti99.com/en/post/2025/09/09/</link><pubDate>Tue, 09 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I experimented with consolidating all my previous coding agent rules into a single &lt;code&gt;AGENTS.md&lt;/code&gt; file, then pointing &lt;code&gt;CLAUDE.md&lt;/code&gt; to read that file.&lt;/del&gt; Enjoy Newsletter #53.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="anti-cheat-secure-boot--tpm"&gt;&lt;a href="https://andrewmoore.ca/blog/post/anticheat-secure-boot-tpm/" rel="noopener noreferrer"&gt;Anti-cheat, Secure Boot &amp;amp; TPM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Moore explains why anti-cheat systems like those in Battlefield 6 or Riot&amp;rsquo;s Vanguard have started requiring players to enable Secure Boot and TPM 2.0, while pushing back against claims that this is a pretext for harvesting player data. Secure Boot relies on a key hierarchy (Platform Key, Key Exchange Key, the DB allowlist of signatures, and the DBX blocklist) to ensure firmware only executes validly signed boot images. Combined with Windows only loading Microsoft-signed kernel drivers, cheat developers have a hard time injecting code into the kernel without an unpatched vulnerability.&lt;/p&gt;
&lt;p&gt;However, an anti-cheat client cannot simply trust the operating system when it reports that Secure Boot is enabled, which is where the TPM becomes the crucial link. The firmware TPM (fTPM) built into modern AMD and Intel CPUs holds a unique Endorsement Key backed by a manufacturer certificate, providing unforgeable hardware identification—meaning a hardware ban forces a cheater to buy a new CPU. In addition, the TPM&amp;rsquo;s PCR registers record a cryptographic hash chain of every event during the boot sequence, and through remote attestation via &lt;code&gt;TPM2_Quote&lt;/code&gt;, the anti-cheat server can verify that the boot environment has not been tampered with. The takeaway: this setup doesn&amp;rsquo;t eliminate cheating completely—especially hardware-based cheats—but it makes ban evasion far more expensive, doesn&amp;rsquo;t compromise user privacy, and forms an important layer of defense in depth.&lt;/p&gt;
&lt;h2 id="left-to-right-programming"&gt;&lt;a href="https://graic.net/p/left-to-right-programming" rel="noopener noreferrer"&gt;Left to Right Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that a program should remain syntactically valid while it is being typed from left to right, so the editor can offer autocomplete and type checking at every step. A classic counterexample is Python&amp;rsquo;s list comprehension: when writing &lt;code&gt;words_on_lines = [line.split() for line in text.splitlines()]&lt;/code&gt;, the variable &lt;code&gt;line&lt;/code&gt; is used before it is declared, so the editor doesn&amp;rsquo;t know its type when you type the dot and cannot suggest methods. By contrast, in Rust (&lt;code&gt;let words_on_lines = text.lines().map(|line| line.split_whitespace());&lt;/code&gt;) or JavaScript, expressions are built from left to right: the source is stated first, and the moment you type a dot, the editor can suggest relevant methods.&lt;/p&gt;
&lt;p&gt;The article connects this to the design principle of &amp;ldquo;progressive disclosure&amp;rdquo;: complexity should only surface when the user actually needs it. In C, because methods cannot be attached to structs, you have to know function names like &lt;code&gt;fread&lt;/code&gt; or &lt;code&gt;fclose&lt;/code&gt; ahead of time rather than discovering them through autocomplete after typing &lt;code&gt;file.&lt;/code&gt;. Python runs into a similar issue with global functions like &lt;code&gt;len&lt;/code&gt; or &lt;code&gt;map&lt;/code&gt;; as logic grows more complex, a single line of Python nesting multiple &lt;code&gt;filter&lt;/code&gt;, &lt;code&gt;lambda&lt;/code&gt;, and comprehension expressions becomes much harder to read than a method chain in JavaScript that reads sequentially from left to right. The closing message for language and library designers is simple: build discoverable APIs.&lt;/p&gt;
&lt;h2 id="big-o-notation"&gt;&lt;a href="https://samwho.dev/big-o/" rel="noopener noreferrer"&gt;Big O Notation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide on samwho.dev introduces Big O notation visually with live in-browser examples. Rather than measuring wall-clock time, Big O describes how execution time grows as input size increases. The author walks through four common complexity classes: summing numbers from 1 to &lt;code&gt;n&lt;/code&gt; with a loop is O(n) (linear), whereas using the formula &lt;code&gt;(n*(n+1))/2&lt;/code&gt; is O(1) (constant)—noting that O(1) does not mean &amp;ldquo;instant,&amp;rdquo; only that runtime does not depend on input size. Bubble sort illustrates O(n²) (quadratic), while guessing a number between 1 and 100 via binary search, halving the search space on each guess, illustrates O(log n) (logarithmic). Big O describes an asymptotic upper bound: O(2n) simplifies to O(n), keeping only the fastest-growing term. You can analyze best, average, or worst cases; the article focuses on the worst case.&lt;/p&gt;
&lt;p&gt;The final section shares practical performance tips: use a hash-table-backed &lt;code&gt;Set&lt;/code&gt; for average O(1) lookups instead of scanning an array (even though building the &lt;code&gt;Set&lt;/code&gt; costs O(n)), avoid calling &lt;code&gt;.indexOf&lt;/code&gt; inside a loop since that quietly turns the whole function into O(n²), and memoize intermediate results—as shown with factorials—to avoid redundant computation at the cost of extra memory. The most important advice: always benchmark before and after changing code, and don&amp;rsquo;t blindly trust performance claims you read online.&lt;/p&gt;
&lt;h2 id="personal-ai-evaluations-august-2025"&gt;&lt;a href="https://darkcoding.net/software/personal-ai-evals-aug-2025/" rel="noopener noreferrer"&gt;Personal AI Evaluations August 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Graham King evaluates large language models (LLMs) against his own day-to-day needs instead of relying on public leaderboards: he selected 12 questions out of 130 prompts from his bash history across four categories (coding, sysadmin, technical explanations, and general knowledge/creative), and ran them against 11 models via OpenRouter—including Claude Sonnet 4, DeepSeek, Gemini 2.5 Flash and Pro, Kimi K2, GPT-OSS-120B, Qwen3, and GLM 4.5. He wrote a custom Rust tool to anonymize the responses for blind grading while recording cost, latency, and throughput for each model.&lt;/p&gt;
&lt;p&gt;His main conclusion is that almost all current models give good answers, making cost and latency the deciding factors. Proprietary models like Gemini 2.5 Pro and Claude Sonnet did not stand out—in fact, they often scored lower than open-weight models while costing dramatically more. Gemini 2.5 Flash was the fastest; Kimi K2, Qwen3, and DeepSeek were among the cheapest; and two DeepSeek models alongside two Qwen3 models achieved the highest average accuracy. Reasoning mode rarely helped outside of a poetry prompt, and the entire evaluation produced only a single hallucination, when GPT-OSS-120B invented a nonexistent movie. Based on these results, the author now queries multiple models in parallel using &lt;code&gt;tmux&lt;/code&gt;: DeepSeek for everyday questions, adding Gemini Flash and Qwen3 when he wants a second opinion, and reserving reasoning models for particularly tough problems.&lt;/p&gt;
&lt;h2 id="how-to-keep-services-running-during-failures"&gt;&lt;a href="https://newsletter.scalablethread.com/p/how-to-keep-services-running-during" rel="noopener noreferrer"&gt;How to Keep Services Running During Failures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post from The Scalable Thread introduces graceful degradation, the design principle of keeping a system&amp;rsquo;s core functionality running when a component fails rather than letting the entire service go down. For example, if a video platform&amp;rsquo;s recommendation service fails, the homepage can fall back to showing trending videos while video playback continues working normally. The first group of strategies focuses on traffic control: rate limiting caps incoming requests during flash sales or DDoS attacks; request coalescing collapses thousands of identical concurrent queries into a single database hit; load shedding proactively drops non-essential requests (such as click tracking) to preserve capacity for checkout transactions; and retries with jitter add random backoff delays to prevent a &amp;ldquo;thundering herd problem&amp;rdquo; when a recovering service comes back online.&lt;/p&gt;
&lt;p&gt;The second group of strategies handles faults and improves observability. A circuit breaker acts like an electrical breaker: when a payment service repeatedly fails, the ordering service trips the breaker and fails fast for a cooldown period (say, 60 seconds) before letting a few probe requests through to check whether the downstream service has recovered. Request timeouts prevent upstream services from exhausting thread pools or connection limits waiting on a slow dependency. Finally, monitoring and alerting on metrics like error rates, latency, and message broker queue depth help engineers catch and contain incidents before they cascade.&lt;/p&gt;
&lt;h2 id="why-was-apache-kafka-created"&gt;&lt;a href="https://bigdata.2minutestreaming.com/p/why-was-apache-kafka-created" rel="noopener noreferrer"&gt;Why Was Apache Kafka Created?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from 2 Minute Streaming explains why Kafka was created in the first place. Around 2012, LinkedIn relied on user activity data to power many core features, but operated two separate data pipelines: an hourly batch system that pushed XML messages through HTTP servers into Oracle and Hadoop data warehouses, and a near-real-time monitoring pipeline built on Zenoss. Both required heavy manual operations, suffered from large backlogs, and consisted of fragile point-to-point connections that couldn&amp;rsquo;t be unified. Specific pain points included parsing hundreds of XML schemas, breaking downstream consumers whenever a schema changed, multi-hour latency, and clean data being locked inside the data warehouse.&lt;/p&gt;
&lt;p&gt;Kafka solved these problems with a distributed, replicated architecture that scales horizontally via partitions, an append-only log structure that supports multiple independent consumers, and disk persistence that decouples producers from consumers. LinkedIn also migrated from XML to Avro (roughly 7x smaller), built a schema versioning service—the precursor to Schema Registry—with backward-compatibility checks, enforced &amp;ldquo;schema on write&amp;rdquo; to validate data before it entered Kafka, and shifted schema ownership to the teams producing the data backed by mandatory review workflows. What surprised the author most is that LinkedIn&amp;rsquo;s original papers emphasized schemas over 13 years ago, whereas he considers the lack of native, built-in schema enforcement to be Kafka&amp;rsquo;s biggest design mistake.&lt;/p&gt;
&lt;h2 id="how-we-vibe-code-at-a-faang"&gt;&lt;a href="https://www.reddit.com/r/vibecoding/comments/1myakhd/how_we_vibe_code_at_a_faang/" rel="noopener noreferrer"&gt;How We Vibe Code at a FAANG&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Reddit user who introduces himself as an AI engineer with over ten years of experience—roughly half of it at FAANG or similar companies—shares how his team integrates AI into a production software development workflow, pushing back against the claim that AI-assisted coding isn&amp;rsquo;t viable for real-world systems. Their process still starts with rigorous technical design docs: a proposal must win stakeholder alignment, followed by a full system design covering architecture and cross-team integrations, and then a design review where senior engineers tear it apart—what the author calls front-loading the pain. Next come subsystem documentation, task breakdowns, and sprint planning with PMs and TPMs.&lt;/p&gt;
&lt;p&gt;Only when it is time to write code does AI become a productivity &amp;ldquo;force multiplier&amp;rdquo;: the team practices Test-Driven Development, having AI agents write the tests first before implementing the feature. Every pull request still requires approval from two human engineers before merging (with AI also starting to assist in code reviews), followed by staging verification before production rollout. According to the poster, end-to-end delivery time from feature proposal to production is about 30% faster. Many commenters pointed out that this isn&amp;rsquo;t really &amp;ldquo;vibe coding&amp;rdquo; at all, but disciplined AI-assisted engineering inside a mature enterprise workflow—a distinction the author himself agreed with.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict on &lt;code&gt;AGENTS.md&lt;/code&gt; effectiveness: Not great yet—it still left quite a lot of English terms untranslated. I&amp;rsquo;ll try to refine it further in upcoming posts. See you next time!&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #52</title><link>https://miti99.com/en/post/2025/09/07/</link><pubDate>Sun, 07 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #52.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="traps-to-developers"&gt;&lt;a href="https://qouteall.fun/qouteall-blog/2025/Traps%20to%20Developers" rel="noopener noreferrer"&gt;Traps to Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This compilation by qouteall is an extensive reference list of programming &amp;ldquo;traps&amp;rdquo;: unintuitive behaviors that are easy to misunderstand and usually only reveal themselves after causing a bug. Organized by topic, it opens with HTML and CSS gotchas such as &lt;code&gt;min-width: auto&lt;/code&gt; in flexbox or grid preventing elements from shrinking, margin collapse, stacking contexts scoping &lt;code&gt;z-index&lt;/code&gt; unexpectedly, and &lt;code&gt;100vh&lt;/code&gt; on mobile browsers exceeding the actual visible viewport. Next come Unicode and text processing, floating-point pitfalls involving &lt;code&gt;NaN&lt;/code&gt;, infinity, and rounding errors, and time-handling traps.&lt;/p&gt;
&lt;p&gt;Later sections cover specific languages and platforms: Java, Go, C/C++, Python, Rust, SQL databases, concurrency and parallelism, transitive dependency conflicts, Linux and bash, backend engineering, React, Git, networking, locales, regular expressions, and the Microsoft ecosystem. Each entry is just a few lines long with reference links, making the post ideal to skim once and bookmark for future debugging sessions. For newer developers, it is a fast way to learn common &amp;ldquo;looks right, but isn&amp;rsquo;t&amp;rdquo; pitfalls without paying for each one in hours of debugging.&lt;/p&gt;
&lt;h2 id="active-record-vs-repository-pattern"&gt;&lt;a href="https://javabulletin.substack.com/p/active-record-vs-repository-pattern" rel="noopener noreferrer"&gt;Active Record vs. Repository Pattern&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Suraj Mishra compares two popular data-access design patterns in object-oriented programming. With Active Record, each class maps directly to a database table, each object corresponds to a row, and the model itself holds CRUD methods like &lt;code&gt;find&lt;/code&gt; or &lt;code&gt;save&lt;/code&gt;, as popularized by Ruby on Rails. This approach is easy to pick up, minimizes boilerplate through &amp;ldquo;convention over configuration,&amp;rdquo; and speeds up development for straightforward applications, but tightly couples domain models to the database schema, violates the Single Responsibility Principle, and easily grows unwieldy as business logic becomes complex.&lt;/p&gt;
&lt;p&gt;The Repository pattern separates data-access logic from business logic behind a collection-like interface; in Spring Data JPA, this typically takes the form of an interface extending &lt;code&gt;JpaRepository&lt;/code&gt; injected into a service class. Unit testing becomes much easier because the repository can be mocked, and swapping out the underlying data store—say, from a relational database to NoSQL—has minimal impact on business logic. The trade-off is an extra layer of abstraction, added ceremony, and slower initial setup. The author concludes that Active Record suits smaller apps with simple domain logic, while the Repository pattern shines when maintainability, scalability, and testability are top priorities.&lt;/p&gt;
&lt;h2 id="threadsleep0-is-not-for-free"&gt;&lt;a href="https://mlangc.github.io/java/performance/2025/08/14/thread-sleep0-is-not-for-free.html" rel="noopener noreferrer"&gt;Thread.sleep(0) is not for free&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post debunks a common misconception: calling &lt;code&gt;Thread.sleep(0)&lt;/code&gt; in Java is not &amp;ldquo;free.&amp;rdquo; Although the official specification allows an implementation shortcut that merely checks interrupt status when the sleep duration is zero, HotSpot&amp;rsquo;s actual implementation crosses into native code and calls &lt;code&gt;os::naked_yield()&lt;/code&gt;—which on Linux invokes &lt;code&gt;sched_yield()&lt;/code&gt;, a system call whose own man page warns against unnecessary use because it triggers costly context switches. In the author&amp;rsquo;s JMH benchmarks, each call costs roughly as much as generating 128 random bytes, and performs worst right when the CPU is under heavy contention: with 20 threads, throughput with &lt;code&gt;Thread.sleep(0)&lt;/code&gt; drops below that of a single thread.&lt;/p&gt;
&lt;p&gt;Therefore, if your code uses &lt;code&gt;sleep&lt;/code&gt; to back off on errors or overload, don&amp;rsquo;t pass a delay of &lt;code&gt;0&lt;/code&gt; into &lt;code&gt;Thread.sleep&lt;/code&gt; like the first snippet below; instead, guard the call so it only sleeps when an actual delay is needed, as in the second snippet. The author also points out that &lt;code&gt;TimeUnit.sleep&lt;/code&gt; documents an explicit no-op for zero or negative durations, and if you genuinely want to yield the CPU, calling &lt;code&gt;Thread.yield()&lt;/code&gt; directly states that intent much more clearly.&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-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;delay&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;allGood&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;0&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;waitShorty&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;sleep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;delay&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;&lt;span class="w"&gt;
&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;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-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;if&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;allGood&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;sleep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;waitShortly&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&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;h2 id="why-do-video-games-use-kernel-mode-anti-cheats"&gt;&lt;a href="https://malwaresourcecode.com/home/my-projects/write-ups/why-do-video-games-use-kernel-mode-anti-cheats" rel="noopener noreferrer"&gt;Why do video games use kernel-mode anti-cheats?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article addresses the widespread fear around kernel-mode anti-cheat software. On Windows, the operating system is split into user mode and kernel mode, with the kernel acting as the &amp;ldquo;manager&amp;rdquo; sitting between software and hardware via drivers. Today, getting a driver into the kernel requires Microsoft vetting and digital signing (Driver Signature Enforcement), while PatchGuard prevents drivers from modifying core kernel structures, and vulnerable drivers can be added to a blocklist. Anti-cheat systems need kernel access because only in kernel mode can they register callbacks—via &lt;code&gt;PsSetCreateProcessNotifyRoutine&lt;/code&gt;—to be notified the moment a process is created, the exact same mechanism used by antivirus and EDR solutions. Newly launched processes are then inspected using static analysis (scanning for known cheat byte signatures) and behavioral analysis such as code-integrity checks, ETW, API hooking, or filesystem minifilters.&lt;/p&gt;
&lt;p&gt;On privacy concerns, the author argues that most fears stem from misconceptions: malicious Microsoft-signed kernel drivers are exceedingly rare, roughly 99.9% of modern malware runs in user mode because attackers need very few privileges to steal user data, and using a kernel driver just to &amp;ldquo;spy&amp;rdquo; on gamers would be massive overkill. Choosing not to trust kernel-mode anti-cheat ultimately comes down to your personal threat model, the author concludes, but that choice shouldn&amp;rsquo;t be based on misinformation.&lt;/p&gt;
&lt;h2 id="why-llms-can"&gt;&lt;a href="https://zed.dev/blog/why-llms-cant-build-software" rel="noopener noreferrer"&gt;Why LLMs Can&amp;rsquo;t Really Build Software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Conrad Irwin (Zed) draws on his interviewing experience to observe that strong software engineers continuously run a three-part loop: build a mental model of the requirements, write code, build a mental model of what the code actually does, and resolve discrepancies by updating either the code or the requirements. LLMs write code reasonably well and can read files, run tests, and add logging, but they fail to maintain a coherent mental model: they assume the code they just wrote is correct, guess randomly between fixing the code or changing the test when a test fails, and wipe everything to start over when stuck. The root cause is that models are bad at recognizing missing context, heavily bias toward the most recent tokens in the context window, and hallucinate details—whereas humans know how to set outer context aside to debug an isolated subproblem before zooming back out to the big picture.&lt;/p&gt;
&lt;p&gt;Even so, the author acknowledges that LLMs are genuinely useful: they generate code quickly, synthesize requirements and documentation well, and can handle simple tasks end to end. For anything non-trivial, however, they cannot yet hold enough accurate context to iterate their way to a working solution. Engineers remain responsible for ensuring requirements are clear and that the code actually does what it claims; at Zed, humans stay in the driver&amp;rsquo;s seat, and LLMs are simply another tool in their hands.&lt;/p&gt;
&lt;h2 id="the-java-type-system-is-broken"&gt;&lt;a href="https://wouter.coekaerts.be/2018/java-type-system-broken" rel="noopener noreferrer"&gt;The Java Type System is Broken&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this 2018 post, Wouter Coekaerts demonstrates type-system loopholes tested against JDK 10. Some holes in Java&amp;rsquo;s type system are intentional for backward compatibility—such as raw types or unchecked casts, which can cause &amp;ldquo;heap pollution&amp;rdquo; where a parameterized type holds an object of the wrong type—but those always trigger compiler warnings. The author instead hunts for constructs that the compiler accepts as completely type-safe without a single warning, yet still throw a &lt;code&gt;ClassCastException&lt;/code&gt; at runtime on a line with no explicit cast. After introducing wildcards and capture conversion, the post walks through how lambdas, local inner classes, inner classes inside generic classes, type-variable bound checks, and outer type variables used as bounds for inner classes can all subvert type safety, along with two &amp;ldquo;honorable mentions&amp;rdquo; involving unboxing in lambdas and &lt;code&gt;TreeSet&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author also uncovered several previously reported bugs along the same lines and filed new bug reports against the JDK. In his view, these edge cases pose no security risk and are unlikely to bite developers by accident, but they serve as a reminder that Java&amp;rsquo;s generics are fragile under the hood and compiler warnings should not be ignored. The post wraps up with the motto &amp;ldquo;everything is broken, everything is fine,&amp;rdquo; alongside a call to give the type system some much-needed care after years of strain from backward compatibility and new language features.&lt;/p&gt;
&lt;h2 id="the-pragmatic-engineer-2025-survey-what"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-pragmatic-engineer-2025-survey-part-2" rel="noopener noreferrer"&gt;The Pragmatic Engineer 2025 Survey: What&amp;rsquo;s in your tech stack? Part 2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part 2 of The Pragmatic Engineer&amp;rsquo;s April–May 2025 reader survey, drawing on roughly 3,000 responses, examines the tools software engineers use for project management, communication, collaboration, data storage, and backend infrastructure. JIRA still leads project management despite being voted the most disliked tool in Part 1, Linear is rising fast as a serious challenger, and Azure DevOps is surprisingly widespread. In communication, Slack dominates team chat, Microsoft Teams leads video calls, Confluence is the most common documentation tool, and Figma dominates design. PostgreSQL is the most frequently mentioned database out of 35 contenders, followed by MySQL, Redis, and MongoDB, while backend infrastructure centers on AWS services, Docker, Kubernetes, and Terraform.&lt;/p&gt;
&lt;p&gt;The author highlights several practical takeaways: project tracking is an integral part of an engineer&amp;rsquo;s job, with issue trackers mentioned nearly as often as IDEs; it is hard to go wrong choosing PostgreSQL, making the pragmatic question &amp;ldquo;what stops us from using Postgres?&amp;rdquo;; and Kubernetes is worth learning even if you don&amp;rsquo;t use it yet, as a quarter of respondents already run it in production. Finally, Redis and Terraform moving away from open-source licenses appears not to have dented their popularity despite open-source forks, while Amazon-backed OpenSearch has reached roughly 25% of Elasticsearch&amp;rsquo;s adoption.&lt;/p&gt;
&lt;h2 id="why-do-software-developers-love-complexity"&gt;&lt;a href="https://kyrylo.org/software/2025/08/21/why-do-software-developers-love-complexity.html" rel="noopener noreferrer"&gt;Why do software developers love complexity?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kyrylo Silin asks why software developers remain drawn to complexity even though everyone knows the KISS principle (Keep It Simple, Stupid). Part of the answer is marketing: nobody gets excited about a plain replacement for &lt;code&gt;cat&lt;/code&gt;, whereas a feature-packed &amp;ldquo;catzilla&amp;rdquo; promoted everywhere sparks curiosity. Complexity also quietly signals effort, expertise, and exclusivity, turning into a status symbol rather than a response to real needs. Like ancient pyramids, modern software stacks dependencies, frameworks, and layers of abstraction sky-high while sometimes remaining hollow inside; as the author puts it, &amp;ldquo;Complexity screams: &amp;lsquo;Look at me!&amp;rsquo; Simplicity whispers: &amp;lsquo;Did you notice?&amp;rsquo;&amp;rdquo; His favorite example is React versus vanilla JavaScript.&lt;/p&gt;
&lt;p&gt;Beyond marketing, the article identifies four internal drivers: the intellectual thrill of solving a hard puzzle, legacy systems and technical debt that make bolting on patches easier than simplifying, large teams where everyone adds &amp;ldquo;just in case&amp;rdquo; abstractions, and pressure to innovate to stand out. His closing advice: if you must build a pyramid, build it with purpose, on a solid foundation, with real value inside; before writing 500 lines of abstraction for something that takes 50 lines of direct code, ask whether you are solving a real problem for users and maintainers or just indulging yourself.&lt;/p&gt;
&lt;h2 id="the-important-things-in-life"&gt;&lt;a href="https://hamvocke.com/blog/important-things/" rel="noopener noreferrer"&gt;The Important Things in Life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ham Vocke explains why his blog has been quiet lately: his spring and summer were filled with the things that make life sweet, leaving no time for writing posts or tinkering on side projects—and he wouldn&amp;rsquo;t change a thing. His job at a growing startup still demands hard work and helps him learn and grow, but the day-to-day challenges, frustrations, and wins at work rarely stick in memory for long. What stays with him are the moments away from the screen: attending weddings and milestone celebrations with friends of over 25 years, going to his first music festival in 20 years, weekend barbecues with friends, visiting a brother after years apart, spending time with his parents as they prepare for retirement, and a weekend getaway with his wife taking in the scenery of southern Germany.&lt;/p&gt;
&lt;p&gt;It is a short piece, but a worthwhile reminder for people in tech about work-life balance, closing with simple advice: &amp;ldquo;Hug your friends, call your family, go outside, and make some memories.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="bonus-cool-diagrams-from-bytebytego"&gt;Bonus: Cool diagrams from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4bf62d5c-e538-4fba-8d4f-aa00d0bd064a_3000x3900.png" alt="How Does SSO Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/e249b1bd-134e-4242-ac16-1d50daf804d3_3000x3900.png" alt="Best Practices in API Design"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/82b8257a-93c3-4861-b211-88d57b12bc93_2250x2624.png" alt="Top Strategies For Reliability and Fault Tolerance"&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos"&gt;Bonus: Interesting videos&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=Dc3qOA9WOnE" rel="noopener noreferrer"&gt;Vibes won&amp;rsquo;t cut it — Chris Kelly, Augment Code&lt;/a&gt;
&lt;a href="https://www.youtube.com/watch?v=Z3fwe6AAgaM" rel="noopener noreferrer"&gt;these coding blogs will make you a better programmer&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-repositories"&gt;Bonus: Interesting repositories&lt;/h2&gt;&lt;p&gt;&lt;a href="https://github.com/bansalankit92/java-spring-fullstack-interview-question-answers" rel="noopener noreferrer"&gt;Computer science foundation/ Interview preparation/ Junior to Senior Developer&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-books"&gt;Bonus: Interesting books&lt;/h2&gt;&lt;p&gt;&lt;a href="https://enos.itcollege.ee/~jpoial/allalaadimised/reading/Java-Interview-Questions.pdf" rel="noopener noreferrer"&gt;Java interview questions and answers - Boosting your java career&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;a href="https://github.com/shannonasmith/Java_books/blob/main/Java%20Puzzlers%20-%20Traps%2C%20Pitfalls%2C%20and%20Corner%20Cases%20%282005%29.pdf" rel="noopener noreferrer"&gt;Java Puzzlers - Traps, Pitfalls, and Corner Cases&lt;/a&gt;&lt;/del&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #31</title><link>https://miti99.com/en/post/2025/05/18/</link><pubDate>Sun, 18 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/18/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="optimizing-our-e2e-pipeline"&gt;&lt;a href="https://slack.engineering/speedup-e2e-testing/" rel="noopener noreferrer"&gt;Optimizing Our E2E Pipeline&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s DevXP team shares how they optimized the end-to-end (E2E) test pipeline for the company&amp;rsquo;s largest monorepo. Previously, each run took about 10 minutes, with nearly half of that spent building the frontend—even when a change didn&amp;rsquo;t touch frontend code at all. With hundreds of pull requests merged daily, that produced thousands of builds per week, each taking nearly 1 GB on AWS S3 and adding up to terabytes of duplicate artifacts.&lt;/p&gt;
&lt;p&gt;Their solution used tools they already had: run &lt;code&gt;git diff&lt;/code&gt; with three-dot syntax to compare the current branch against its merge-base with &lt;code&gt;main&lt;/code&gt;; if no frontend files changed, skip the build step and reuse a recent production build served through an internal CDN. Even in a repository with over 100,000 files, detecting changes and locating a matching build takes under 3 seconds. As a result, total builds dropped by 60%, saving hundreds of compute hours per month and several terabytes of storage, while average build time fell from about 5 minutes to 2 minutes (and combined with an earlier Webpack upgrade, from 10 minutes down to 2 minutes overall). As an unexpected bonus, tests also became more stable and less flaky. The takeaway: regularly question which pipeline steps are actually necessary, even in systems that aren&amp;rsquo;t visibly broken.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="doordash"&gt;&lt;a href="https://careersatdoordash.com/blog/doordash-fast-travel-estimates/" rel="noopener noreferrer"&gt;DoorDash&amp;rsquo;s Fast Travel Estimates&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DoorDash engineers explain how they estimate travel distance and duration in milliseconds—a core input for finding nearby stores, predicting delivery ETAs, calculating fees, and matching dashers. Calling a routing engine like OSRM directly typically takes over 100 ms, which is too slow for latency-sensitive paths like homepage refreshes or search ranking, while straight-line (haversine) distance is fast but inaccurate because it ignores real road networks.&lt;/p&gt;
&lt;p&gt;Their answer is Geo-Grid-Cache: partition the entire service area into hexagonal cells using the H3 spatial index, then precompute travel times between cell centers with OSRM under average traffic conditions. Each pair is stored across three resolution tiers—fine for trips under a mile, medium, and coarse for distances up to 100 miles—balancing cache hit rate, storage cost, and accuracy. At request time, the system looks up the pair in a Redis cluster and picks the highest resolution available. The hardest part was generating offline data for roughly 6 billion cell pairs; the team ran Spark on Databricks and installed OSRM directly on the cluster nodes to replace network calls with local HTTP calls, speeding up generation by 10x. The result is ultra-low latency, accuracy close to the internal routing engine, and major compute savings.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="tech-hiring-is-this-an-inflection-point"&gt;&lt;a href="https://blog.pragmaticengineer.com/tech-hiring-is-this-an-inflection-point/" rel="noopener noreferrer"&gt;Tech Hiring: Is This an Inflection Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (The Pragmatic Engineer) highlights a paradox: even though fewer companies are hiring and more candidates are competing for roles, many engineering managers say 2025 is the hardest hiring market they have ever seen. A telling case is maestro.dev, a fully remote startup: every LinkedIn job posting draws hundreds of mostly unqualified applications, cover letters are almost universally AI-generated, and many candidates read answers straight from AI tools during live coding interviews. When the team switched to a take-home assignment, the head of engineering embedded a hidden prompt instruction aimed at AI assistants inside the spec—all four submissions followed the hidden instruction, even though three of the candidates insisted they hadn&amp;rsquo;t used AI. The most reliable signal came instead from candidates who reached out directly to explain why they wanted to join.&lt;/p&gt;
&lt;p&gt;Another remote company had to fire a senior data engineer after just two weeks upon discovering the person had fabricated their experience and used multiple AI tools simultaneously to pass the interview loop. That company is now considering adding a final in-person interview round despite the $1,500–$2,000 cost per candidate, while leaning harder on referrals since 4 of its last 5 hires came through internal recommendations. The post also covers LinkedIn Recruiter costs of $5,000–$20,000 per seat per month, the rise of paid &amp;ldquo;work trial&amp;rdquo; weeks, and the need to redesign remote hiring from the ground up in the AI era.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="underusing-snapshot-testing"&gt;&lt;a href="https://matklad.github.io/2025/04/15/underusing-snapshot-testing.html" rel="noopener noreferrer"&gt;Underusing Snapshot Testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aleksey Kladov (matklad), creator of rust-analyzer, explains why he thinks he still underuses snapshot testing. The idea is straightforward: serialize a test&amp;rsquo;s output into text, compare it against an expected string literal embedded right in the source file, and use a tool to automatically update that literal from the actual output. The obvious benefit is easy maintenance when requirements change: the tool rewrites the expected output so the author can review the diff instead of editing strings by hand.&lt;/p&gt;
&lt;p&gt;What surprised him came from implementing permutation encoding in Zig—a problem whose requirements never change. With traditional assertion-based tests, execution stops at the first failure and the output is buried in a terminal window far from the code. Switching to inline snapshots surfaced every wrong result right inside the source file, letting him see the full picture at once and quickly spot two off-by-one bugs. In his view, snapshot tests keep data close to the programmer, tighten the feedback loop, and act like a repeatable REPL, speeding up development even when requirements are fixed. The end of the post also explains why a handful of concrete examples remain valuable alongside exhaustive testing over all permutations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="principles-for-coding-securely-with-llms"&gt;&lt;a href="https://www.seangoedecke.com/ai-security/" rel="noopener noreferrer"&gt;Principles for coding securely with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that LLM security shouldn&amp;rsquo;t be treated as a long checklist of disconnected threats, but derived from a single principle: LLMs sometimes act maliciously, so treat their output like untrusted user input. Prompt injection is fundamentally unavoidable—the moment you bring third-party content (web pages, docs, Cursor rules files) into the context window, you give its author a chance to steer the model, and no model is immune to jailbreaks.&lt;/p&gt;
&lt;p&gt;From that principle, every tool an LLM is allowed to call should be scoped and authorized like a public user-facing API: for example, expose &lt;code&gt;fetch_messages()&lt;/code&gt; rather than &lt;code&gt;fetch_messages(user_id)&lt;/code&gt; so the model cannot read another user&amp;rsquo;s messages, and require explicit human confirmation for high-impact actions like sending messages or transferring money. MCP servers are effectively remote libraries, meaning you are trusting the server&amp;rsquo;s owner, not just its interface. Even without an attacker, LLMs can hallucinate or take reckless actions, so human approval gates must be enforced in tool code rather than requested in the prompt. Goedecke also notes risks from fine-tuned or self-trained models (goal misalignment or leaking sensitive training data) and denial-of-service (DoS) attacks, since LLM calls are slow and GPU-heavy—cap concurrent sessions, token budgets, and tool access accordingly.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-i-don"&gt;&lt;a href="https://www.gleech.org/llms" rel="noopener noreferrer"&gt;How I don&amp;rsquo;t use LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin Leech, an AI PhD, candidly explains why he rarely uses LLMs for intellectual work despite knowing firsthand how capable they are. Every time a new frontier model comes out, he tries it, and every time it confidently makes a serious error within the first few minutes. His reasons include loving writing enough that editing weak prose takes more effort than drafting from scratch, already having solid foundational knowledge across many fields, needing high accuracy and reliability when learning, disliking the model&amp;rsquo;s voice and habit of bluffing, worrying about skill atrophy, and not writing much code at the time.&lt;/p&gt;
&lt;p&gt;Even so, he still uses LLMs in specific situations: as a search replacement (only when citations are provided), for tip-of-the-tongue term recall, finding entry-point keywords in an unfamiliar field, semantic search over document collections, validating and converting JSON to CSV, getting past blank-page syndrome, and especially writing Matplotlib code or untangling Docker, WSL, and Cloudflare issues. To bypass model sycophancy, he frames his own ideas as if they came from someone else. The post strikes a balanced, self-critical tone: Leech admits part of the problem may be his own impatience, while warning that LLMs can quietly plant a few plausible falsehoods in your head every day.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-senior-software-engineers-can-learn-from-junior-engineers"&gt;&lt;a href="https://www.infoq.com/news/2025/04/software-engineers-learning/" rel="noopener noreferrer"&gt;How Senior Software Engineers Can Learn from Junior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This InfoQ piece summarizes Beth Anderson&amp;rsquo;s QCon London talk on what senior engineers can learn from junior teammates. She notes that steep power distances on a team make junior engineers hesitant to speak up even when they spot a problem with serious consequences, stifling innovation and collaboration. Rather than treating mentorship as a one-way street, senior engineers should recognize that junior colleagues often bring high energy, fresh perspectives, and up-to-date skills.&lt;/p&gt;
&lt;p&gt;To build an inclusive culture, Anderson recommends active listening, amplifying others&amp;rsquo; voices, crediting contributions, and creating the psychological safety needed for juniors to ask questions freely. One concrete practice is &amp;ldquo;reverse feedback&amp;rdquo;: asking junior engineers to critique how seniors communicate with them, asking how they prefer to learn, and inviting them to review senior engineers&amp;rsquo; code and pull requests as a learning exercise. She also urges juniors not to repeat the dismissive behaviors that once frustrated them when they become seniors themselves, because seniority is not about authority—it is an opportunity to create positive change. Every engineer, at every level, has a perspective worth learning from if we are willing to listen.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="as-an-engineer-i"&gt;&lt;a href="https://shiftmag.dev/asking-questions-engineering-career-advice-4895/" rel="noopener noreferrer"&gt;As an engineer, I&amp;rsquo;d rather be called stupid than stay silent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marko Antanaskovic recounts overcoming imposter syndrome while working as a Customer Support Engineer at Infobip. Opening with a fictional incident call packed with impenetrable jargon, he captures a familiar feeling: not understanding what the developers are saying, yet staying quiet out of fear of looking stupid while the customer waits for an update. Realizing nobody could know everything across such a massive platform—and that no textbook covered it—he decided to tap the knowledge of his colleagues by asking &amp;ldquo;stupid&amp;rdquo; questions like &amp;ldquo;What does that actually mean?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Antanaskovic points out the real cost of silence: prolonged outages because nobody connects the technical symptom to customer impact, poor work caused by misunderstood requirements, and meetings that sink into awkward silence. To build a questioning culture, he suggests being the first to ask, shifting from blame to education in the spirit of a blameless culture, and trusting the people around you. That willingness to look &amp;ldquo;stupid&amp;rdquo; helped him build enough deep system knowledge to transition into a Reliability Operations Engineer role. His closing takeaway: no sincere question is stupid, and it is far better to risk looking foolish than to stay silent and make preventable mistakes.&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 #22</title><link>https://miti99.com/en/post/2025/05/09/</link><pubDate>Fri, 09 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #22.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="identity-tokens-best-practices"&gt;&lt;a href="https://www.permit.io/blog/identity-tokens-best-practices" rel="noopener noreferrer"&gt;Identity Tokens Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel L. Manor (Permit.io) explains that an identity token is a signed package of claims issued by an identity provider to represent a user or service, typically built on OAuth 2.0, OpenID Connect, and the JWT format consisting of a header, a payload containing claims like &lt;code&gt;iss&lt;/code&gt;, &lt;code&gt;exp&lt;/code&gt;, and &lt;code&gt;sub&lt;/code&gt;, and a digital signature. The article distinguishes common token types: JWTs, OpenID Connect ID tokens, opaque tokens (random strings whose underlying data is stored server-side), and API keys for service-to-service communication. The biggest advantage is delegated authentication: applications don&amp;rsquo;t have to handle passwords directly and only need to validate the token (signature, issuer, audience, and expiration), making single sign-on (SSO) and scaling microservices straightforward.&lt;/p&gt;
&lt;p&gt;The most valuable section covers common anti-patterns: treating identity tokens as the source of truth for all authorization decisions, stuffing way too much data (permission lists, URLs, entire user objects) into token claims, setting expiration times too short or too long, and maintaining completely separate authentication flows for human users versus machines. The core recommendation is decoupling authentication (who you are) from authorization (what you are allowed to do right now) so policies can change without reissuing tokens. Beyond that, keep tokens small, stick to open standards, balance token lifetimes, plan for token revocation, always transmit tokens over HTTPS, keep them out of logs and URLs, and always verify JWT signatures. Note that since this is the blog of an authorization vendor, it includes a brief product pitch alongside the technical advice.&lt;/p&gt;
&lt;h2 id="tactical-work-in-the-age-of-layoffs"&gt;&lt;a href="https://www.seangoedecke.com/tactical-work-in-the-age-of-layoffs" rel="noopener noreferrer"&gt;Tactical Work in the Age of Layoffs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke observes that the golden era of 2010s tech—when companies actively protected work-life balance—is over; today&amp;rsquo;s leadership demands faster delivery and higher output against a backdrop of layoff anxiety. The naive response is keeping your existing work habits and simply working longer hours: that works in the short term, but leads to burnout, mistakes, and unsustainability. Instead, Goedecke advises deploying your time more tactically, because companies don&amp;rsquo;t care how many hours you work—they care about the volume of visible output you deliver.&lt;/p&gt;
&lt;p&gt;Specifically, when under pressure, you can scale back work that is genuinely useful for the codebase but goes unrewarded as &amp;ldquo;free labor&amp;rdquo;: writing comprehensive tests, refactoring legacy code, proactively helping other teams unasked, exploring new technologies, or improving internal processes. The litmus test is simple: would you be willing to do that work for free? Goedecke isn&amp;rsquo;t advocating abandoning all craft—he still voluntarily writes a few integration tests for critical flows. His second piece of advice is to go all-in when your project has executive visibility (clues: your manager&amp;rsquo;s manager attends the kickoff, or the project gets mentioned in company-wide all-hands), and then coast to recover during quieter stretches, because nobody can sprint forever without burning out.&lt;/p&gt;
&lt;h2 id="tracing-thoughts-in-language-model"&gt;&lt;a href="https://www.anthropic.com/research/tracing-thoughts-language-model" rel="noopener noreferrer"&gt;Tracing Thoughts in Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic introduces its latest mechanistic interpretability research, likening the effort to building an &amp;ldquo;AI microscope&amp;rdquo; to peer inside a language model&amp;rsquo;s internals. Because language models are not programmed directly by humans—instead learning problem-solving strategies during training—even their creators don&amp;rsquo;t fully understand how they arrive at answers. Two companion papers extend Anthropic&amp;rsquo;s earlier work from identifying individual internal concepts (&amp;ldquo;features&amp;rdquo;) to linking them together into computational &amp;ldquo;circuits,&amp;rdquo; applying the method to study Claude 3.5 Haiku across ten representative behaviors.&lt;/p&gt;
&lt;p&gt;The findings are full of surprises. Claude appears to think in a shared conceptual space across languages, and this language-agnostic representation grows larger with model scale. When writing rhyming poetry, the model selects the rhyming word at the end of a line in advance and then composes the line to land on it, even though it was trained purely to predict one token at a time. When doing mental arithmetic like 36+59, it runs two parallel pathways—one computing a rough magnitude estimate and another computing the exact ones digit—yet when asked to explain how it got the answer, it recites the standard textbook carrying algorithm instead. Researchers also caught the model fabricating plausible-sounding post-hoc reasoning to agree with a user&amp;rsquo;s incorrect hint, and found that by default Claude is wired to abstain from guessing unless a specific circuit suppresses that reluctance when it recognizes a known entity. The team notes that their current method still captures only a small fraction of the model&amp;rsquo;s total computation.&lt;/p&gt;
&lt;h2 id="why-duplicating-environments-for-microservices-backfires"&gt;&lt;a href="https://www.signadot.com/blog/why-duplicating-environments-for-microservices-backfires" rel="noopener noreferrer"&gt;Why Duplicating Environments for Microservices Backfires&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arjun Iyer (Signadot) argues that in microservices development, the time it takes to test a code change in a production-like environment determines engineering velocity—and the common approach of spinning up full duplicate environments on demand for each developer or team (via VMs, Kubernetes namespaces, or dedicated clusters) breaks down as systems grow. Every environment requires the full set of services, load balancers, API gateways, databases, and message queues, making it painful to manage; teams resort to mocks that drift from reality, test data falls out of sync, environments quickly lag behind &lt;code&gt;main&lt;/code&gt;, and provisioning gets slower and slower. The cloud bill is steep too: running a 50-microservice environment on an EC2 &lt;code&gt;m6a.8xlarge&lt;/code&gt; instance costs roughly $11,232 per year, which multiplied across 50 copies exceeds $560,000 in compute alone.&lt;/p&gt;
&lt;p&gt;The alternative Iyer proposes is sharing a single baseline environment with request-level isolation via lightweight &amp;ldquo;sandboxes,&amp;rdquo; similar to Uber&amp;rsquo;s end-to-end testing architecture: only the modified services are deployed into a sandbox, while requests are dynamically routed based on headers. This saves compute, produces consistent results, simplifies maintenance, spins up sandboxes nearly instantly, and stays much closer to production. Implementing it requires three pieces: context propagation across service boundaries (using OpenTelemetry &lt;code&gt;baggage&lt;/code&gt; and &lt;code&gt;tracecontext&lt;/code&gt; standards), data isolation so tests cannot mutate shared baseline records they didn&amp;rsquo;t create, and message-queue routing so sandboxes don&amp;rsquo;t compete for the same events.&lt;/p&gt;
&lt;h2 id="logging-practices-i-follow"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2023/01/06/logging-practices-I-follow" rel="noopener noreferrer"&gt;Logging Practices I Follow&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Eliran Turgeman shares the logging principles he follows, starting from the observation that logs are the most fundamental observability tool and that their primary audience is developers themselves. Before adding a log statement, ask yourself: is this log truly necessary, or does it duplicate information already logged elsewhere in the same flow; could the logged object blow up in size in production—and if so, can you log just a count or a few key fields instead; and does this message actually help someone debug or understand the execution path? Next, keep log formatting consistent across the entire system—for example, always prefixing messages with &lt;code&gt;[serviceName](functionName)&lt;/code&gt; so engineers can locate the exact call site without even opening the codebase.&lt;/p&gt;
&lt;p&gt;For log levels, Turgeman sticks mainly to four: &lt;code&gt;ERROR&lt;/code&gt; when part of a flow fails and needs to page someone on call, &lt;code&gt;WARNING&lt;/code&gt; for abnormal behavior worth investigating, &lt;code&gt;INFO&lt;/code&gt; for major milestones in a request flow, and &lt;code&gt;DEBUG&lt;/code&gt; for fine-grained inspection of objects and data structures; the most common mistakes are logging way too much detail at &lt;code&gt;INFO&lt;/code&gt; or never using &lt;code&gt;DEBUG&lt;/code&gt; at all. Finally, be mindful of cost: dumping a massive JSON payload into logs is both unreadable and expensive—at roughly $0.50 per GB in AWS CloudWatch, a single noisy log line can easily cost thousands of dollars a month. Making every log message unique across the codebase, aided by the service and function prefix, makes troubleshooting much faster.&lt;/p&gt;
&lt;h2 id="sync-and-async"&gt;&lt;a href="https://blogs.newardassociates.com/blog/2025/sync-and-async.html" rel="noopener noreferrer"&gt;Sync and Async&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ted Neward argues that the &amp;ldquo;work from home (WFH) versus return to office (RTO)&amp;rdquo; debate focuses on the wrong question: the real issue isn&amp;rsquo;t &lt;em&gt;where&lt;/em&gt; work happens, but &lt;em&gt;how&lt;/em&gt; work happens—specifically, synchronous versus asynchronous work. After recapping the pandemic shift to remote work and the subsequent wave of hybrid policies and RTO mandates, Neward lays out his premises: we still have no objective metric for developer &amp;ldquo;productivity,&amp;rdquo; remote teams can be led effectively by skilled managers, talent is distributed everywhere, yet human relationships deepen faster face-to-face—and commuting into an office just to sit on Zoom calls with headphones on makes no sense.&lt;/p&gt;
&lt;p&gt;He defines &amp;ldquo;synchronous&amp;rdquo; work as tasks that require back-and-forth interaction with others to make progress, and &amp;ldquo;asynchronous&amp;rdquo; work as tasks where you can move forward independently without waiting on new input. Writing code and debugging are largely asynchronous (even if rubber-ducking a bug with a colleague helps); pair programming and requirements gathering with stakeholders are synchronous; code reviews and architecture brainstorming alternate between both. Rather than a binary, sync and async form a spectrum, which Neward maps across two axes: degree of synchronicity and communication fidelity (bandwidth). Activities high on both axes—like pair programming or design brainstorming—benefit most from being in the same room, while activities low on both—like heads-down coding—can be done from anywhere.&lt;/p&gt;
&lt;h2 id="making-uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/making-ubers-experiment-evaluation-engine-100x-faster/" rel="noopener noreferrer"&gt;Making Uber&amp;rsquo;s Experiment Evaluation Engine 100x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber&amp;rsquo;s engineering team recounts how they cut A/B experiment evaluation latency for Go backend microservices by 100x, dropping p99 latency from roughly 10 ms to 100 µs. Previously, every active experiment was evaluated via remote RPC calls to a centralized Parameter Service. That approach was too slow for Uber&amp;rsquo;s real-time paths, turned the central service into a single point of failure, and forced developers to rely on batch prefetching—requiring them to know upfront which parameters a request would need, with any omission causing bugs. Their solution was moving to local evaluation: distributing experiment metadata to every host over Uber&amp;rsquo;s existing Flipr configuration distribution channel and running the evaluation logic inside an in-process &lt;code&gt;ExperimentPlugin&lt;/code&gt; within the client library.&lt;/p&gt;
&lt;p&gt;To guarantee correctness during the migration, the team ran shadow testing across a sample of roughly 20 million evaluations per second, comparing legacy and local results, fixing 13 edge-case bugs, and achieving over 99.999% parity. Because faster evaluations also meant impression logs were pushed to Kafka at a much higher rate, they added monitoring, alerting, and an in-memory LRU cache that deduplicated roughly 80% of redundant exposure logs, along with internal kill-switch parameters to disable features instantly without redeployment. Today, more than 100 services representing nearly 70% of experiment traffic have migrated, cutting UberEats search autocomplete indexing latency by 20%. Their takeaway: start with a simple centralized architecture, and only decentralize once your platform is mature enough to handle it.&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 #7</title><link>https://miti99.com/en/post/2025/03/16/</link><pubDate>Sun, 16 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #7.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-llm-curve-of-impact-on-software-engineers"&gt;&lt;a href="https://serce.me/posts/2025-02-07-the-llm-curve-of-impact-on-software-engineers" rel="noopener noreferrer"&gt;The LLM Curve of Impact on Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov proposes a hypothesis to explain the sharp divide over how useful LLMs really are: their day-to-day value depends heavily on an engineer&amp;rsquo;s seniority, tracing out a distinct curve. For Junior engineers who are still building their mental models of code, LLMs are a lifesaver when deciphering errors, implementing small features, or upgrading libraries. Yet this is also a danger zone: if they just copy and paste code back and forth without understanding why it works, their fundamental skills can stagnate. Mid-level engineers still write code and pick up new frameworks faster with LLMs, but increasingly run into tasks LLMs can&amp;rsquo;t handle—such as figuring out what a customer actually wants from a vague request, hunting down race conditions in a debugger, or handling a 2 a.m. production outage.&lt;/p&gt;
&lt;p&gt;Under this hypothesis, Senior engineers are the most skeptical group. They already hold the system&amp;rsquo;s architecture in their heads, spend a smaller fraction of their day typing boilerplate, and focus on work—roadmapping, debugging gnarly non-reproducible issues, writing design docs—that depends on deep organizational and system context the LLM doesn&amp;rsquo;t have; the more specialized the domain, the sharper the disillusionment. At the Staff+ level, however, the curve bends back up: their job often involves prototyping to blaze trails for other teams, and LLMs drastically speed up building proofs of concept, while their deep expertise lets them immediately spot and untangle whatever corners the model paints itself into. Understanding this curve, the author suggests, builds empathy: the skeptics and the enthusiasts are simply doing very different jobs.&lt;/p&gt;
&lt;h2 id="you-are-using-cursor-ai-incorrectly"&gt;&lt;a href="https://ghuntley.com/stdlib/" rel="noopener noreferrer"&gt;You are using Cursor AI incorrectly&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Geoffrey Huntley argues that most engineers—from juniors to principals—are using Cursor the wrong way: treating it as a Google replacement, writing bare-bones prompts like &amp;ldquo;implement XYZ,&amp;rdquo; using it as a text editor rather than an autonomous agent, and failing to realize that you can &amp;ldquo;program&amp;rdquo; the probability distribution of an LLM&amp;rsquo;s output. His solution is to build a personal &amp;ldquo;stdlib&amp;rdquo; (standard library) of thousands of rules stored in &lt;code&gt;.cursor/rules/&lt;/code&gt;, where each rule is a structured &lt;code&gt;.mdc&lt;/code&gt; file defining filters and actions, named with a consistent convention, and composed together like Unix pipes.&lt;/p&gt;
&lt;p&gt;With these rules in place, you can shape Cursor&amp;rsquo;s behavior permanently: when Cursor kept suggesting Bazel commands even though the author wanted Nix exclusively, he wrote a &lt;code&gt;no_bazel&lt;/code&gt; rule to banish Bazel suggestions altogether. Rules also automate development workflows, such as automatically inserting license headers into new files or committing changes once a task is complete. By the author&amp;rsquo;s estimate, current LLMs are only about 45% accurate out of the box and need constant steering, so continuously curating and refining your rule library is the key to getting real leverage out of Cursor.&lt;/p&gt;
&lt;h2 id="how-do-you-spend-your-time"&gt;&lt;a href="https://brooker.co.za/blog/2024/02/06/time.html" rel="noopener noreferrer"&gt;How Do You Spend Your Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker writes for engineers who feel constantly busy and get plenty done, yet worry they aren&amp;rsquo;t spending their time on the highest-value work for their team and projects. His approach is to set an explicit &amp;ldquo;time budget&amp;rdquo;: pick five or six broad categories of work along with a target percentage of time for each, stay flexible week to week while holding the line over the long run, and review the breakdown periodically with your manager. The act of writing the budget down is the most valuable part, because it forces you to think hard about what success actually looks like in your role. His own buckets include individual technical work (writing, reading, and reviewing code, debugging, design docs), mentoring and teaching, long-term strategy, day-to-day operational rhythm, learning (reading papers, prototyping algorithms), and talking with customers. The exact split matters less than doing the exercise deliberately.&lt;/p&gt;
&lt;p&gt;Sticking to a time budget requires learning to say &amp;ldquo;no.&amp;rdquo; Brooker warns against several traps: chasing high-visibility shiny objects or hype, getting sucked into urgent but low-importance chores, and letting your calendar run away from you—like a senior engineer sitting in 20 hours of meetings a week where nobody sees him contributing much, simply because everyone assumes someone else invited him for a good reason. He applies this same lens at the organizational level and borrows the economics concept of &amp;ldquo;revealed preference&amp;rdquo;: how we actually spend our hours reveals our true priorities, just like claiming you love salad while ordering a burger every day.&lt;/p&gt;
&lt;h2 id="we-are-destroying-software"&gt;&lt;a href="https://antirez.com/news/145" rel="noopener noreferrer"&gt;We are destroying software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a short, manifesto-style post, Redis creator Salvatore Sanfilippo (antirez) lists the ways we are collectively &amp;ldquo;destroying&amp;rdquo; software: piling on features and premature optimizations without weighing their complexity cost; adopting convoluted build systems; assembling absurd dependency chains that leave everything bloated and fragile; telling junior programmers &amp;ldquo;don&amp;rsquo;t reinvent the wheel&amp;rdquo; when reinventing the wheel is precisely how you learn how wheels work—and the first step toward inventing better ones; abandoning API backward compatibility; pushing rewrites of battle-tested code that already works; and chasing every new language, paradigm, and framework fad.&lt;/p&gt;
&lt;p&gt;He also criticizes the habit of underestimating the cost of wrestling with sprawling third-party libraries compared to writing a focused solution yourself, assuming generic industry standards are always better than custom-fit designs, dismissing code comments as useless, and treating software as a purely mechanical engineering discipline. We build systems that cannot &amp;ldquo;scale down&amp;rdquo;—where simple things ought to remain simple—and optimize for coding velocity over design quality. The end result, he warns, is a field stripped of the joy of hacking.&lt;/p&gt;
&lt;h2 id="nontraditional-red-teams"&gt;&lt;a href="https://zachholman.com/posts/red-teams" rel="noopener noreferrer"&gt;Nontraditional Red Teams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Former GitHub engineer Zach Holman expands the concept of a &amp;ldquo;red team&amp;rdquo; (adversarial testers who probe a system for weaknesses) beyond cybersecurity to three everyday roles every product team should have. First is the person who checks whether a new graphic or logo accidentally looks like genital or NSFW imagery: GitHub once came dangerously close to printing its very first highway billboard with an illustration that looked uncannily like the infamous &amp;ldquo;goatse&amp;rdquo; shock image, even after dozens of employees had signed off on it. After that near miss, major design launches at GitHub included a dedicated review step asking how a visual might be misread, mocked, or abused out of context. Second is the ad-blocker user, who speaks up whenever a site breaks navigation simply because a tracking script or HTML snippet got blocked—one of the most frustrating experiences on the modern web.&lt;/p&gt;
&lt;p&gt;Third is the password-manager user. Holman vents about how many teams botch even the most basic login forms with custom inputs that prevent 1Password and similar tools from autofilling credentials. None of these are fatal showstoppers since determined users will eventually work around them, he notes, but they are completely avoidable self-inflicted wounds. When a team is heads-down shipping new features, it&amp;rsquo;s easy to miss these rough edges—which is why having an adversarial &amp;ldquo;red team&amp;rdquo; look at the product with fresh, skeptical eyes pays off.&lt;/p&gt;
&lt;h2 id="ai-or-die"&gt;&lt;a href="https://www.rkg.blog/ai-or-die.php" rel="noopener noreferrer"&gt;AI or Die&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ravi Gupta (RKG) opens with Anthropic CEO Dario Amodei&amp;rsquo;s prediction that as early as 2026 we could see AI models smarter than a Nobel Prize winner across most disciplines, capable of autonomously executing multi-day tasks and running millions of instances in parallel at 10x to 100x human speed—&amp;ldquo;a country of geniuses in a datacenter.&amp;rdquo; Gupta asks: is your company ready to harness that capability, or compete against companies that do? Even today&amp;rsquo;s models can already perform a substantial share of economically valuable work, yet most people barely scratch the surface because they lack ambition, lack the patience to supply rich context, and lack clear thinking and communication.&lt;/p&gt;
&lt;p&gt;To prepare, RKG recommends dedicating a full week to studying what AI can do today and where it is heading; tasking a tiny group to build an &amp;ldquo;AI-native&amp;rdquo; version of your product with a team 10x to 100x smaller; accepting that customers will soon demand dramatically better products at a fraction of the price; going &amp;ldquo;AI-first&amp;rdquo; with the same urgency Facebook once brought to mobile; and auditing every role in the organization to understand who will be supercharged by AI and which functions will be replaced. This isn&amp;rsquo;t an incremental tweak, he argues, but a full-scale &amp;ldquo;refounding&amp;rdquo; of the company—harder the larger and more successful you already are, yet essential to meet a future where, as Sam Altman put it, &amp;ldquo;maybe everyone on earth will be able to accomplish more than the most impactful person can today.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>