<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>AI Engineering on miti99</title><link>https://miti99.com/en/tags/ai-engineering/</link><description>Recent content in AI Engineering 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/ai-engineering/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #119</title><link>https://miti99.com/en/post/2026/07/07/</link><pubDate>Tue, 07 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #119.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="special-cases-in-go"&gt;&lt;a href="https://www.dolthub.com/blog/2026-05-22-special-cases-in-go/" rel="noopener noreferrer"&gt;Special Cases in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go is frequently marketed as a &amp;ldquo;simple&amp;rdquo; language that deliberately avoids special cases. Nick Tobey points out that Go actually has plenty of exceptions hiding in unexpected places. The &lt;code&gt;init&lt;/code&gt; function is the clearest example: it runs automatically when a package is imported, takes no arguments, returns no values, can be declared multiple times within the same package, yet cannot be called manually. If you try to call it, the compiler reports &lt;code&gt;undefined: init&lt;/code&gt; without further explanation. Similarly, the &lt;code&gt;internal&lt;/code&gt; directory creates a visibility scope narrower than public/private, yet that rule doesn&amp;rsquo;t exist in the Go language specification at all—it is enforced by the &lt;code&gt;go&lt;/code&gt; toolchain.&lt;/p&gt;
&lt;p&gt;The reason is that the language spec intentionally leaves import path interpretation implementation-defined. That flexibility lets build systems like Bazel apply their own rules while allowing the standard &lt;code&gt;go&lt;/code&gt; toolchain to evolve without amending the language spec—adding special cases like &lt;code&gt;internal&lt;/code&gt; directories or &lt;code&gt;_test&lt;/code&gt; package suffixes that live in the same directory as the package under test. Tobey also notes that a package&amp;rsquo;s declared name doesn&amp;rsquo;t have to match its directory name, forcing IDEs to parse every imported package just to resolve where an identifier comes from; for new code, explicit import aliases avoid the ambiguity. The broader takeaway: while most of these quirks rarely get in the way of day-to-day work, they show that a language&amp;rsquo;s simplicity often just means the complexity was pushed somewhere else.&lt;/p&gt;
&lt;h2 id="writing-code-vs-shipping-code-productivity-effects-across-generations-of-ai-coding-tools"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/writing-code-vs-shipping-code.html" rel="noopener noreferrer"&gt;Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Murat Demirbas analyzes an MIT and Wharton study that combines internal Microsoft telemetry with public GitHub traces from over 100,000 developers to measure the real-world productivity impact of AI coding tools. The study divides tools into three generations: autocomplete, synchronous agents like Claude Code or Cursor, and asynchronous agents. Output gains at the lines-of-code level are striking, but attenuate sharply at each downstream stage—from files to commits, pull requests, repositories, and finally shipped releases: with autocomplete, lines of code jump by over 228% while shipped releases rise by only ~10%; with synchronous agents, the corresponding numbers are 741% and 20%.&lt;/p&gt;
&lt;p&gt;While Demirbas is skeptical of applying a linear manufacturing production function to software development, he finds the framing useful because it exposes human coordination and review costs. Translating the findings into Amdahl&amp;rsquo;s Law, he calculates that the parallelizable, acceleratable fraction of software work sits right around 35% across all three tool generations—matching the share of time developers actually spend writing code. Agents produce more shipped releases not because they expand that 35% slice, but because they accelerate it more aggressively and intervene closer to the finish line. The remaining 65%—understanding the problem, planning, team alignment, and code review—remains a serial bottleneck. To genuinely ship faster, organizations have to improve those non-coding stages rather than just generating code faster.&lt;/p&gt;
&lt;h2 id="when-was-the-last-time-you-did-just-one-thing"&gt;&lt;a href="https://alifeengineered.substack.com/p/when-was-the-last-time-you-did-just" rel="noopener noreferrer"&gt;When Was the Last Time You Did Just One Thing?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Huynh recounts packing for a long trip: downloading dozens of YouTube videos, queueing up a backlog of podcasts, packing a handheld game console, two physical books, a Kindle, and his laptop just in case he wanted to get some work done. Then it hit him that this entire &amp;ldquo;arsenal&amp;rdquo; against a single moment of boredom would cause him to miss the trip itself—and that paradoxically, the harder we try not to waste a single second, the emptier every second feels. While the public preview ends there, the message from the title and setup is unmistakable: doing just one thing at a time is no longer our default state, but a skill we have to actively practice.&lt;/p&gt;
&lt;p&gt;For people in tech, it is a timely reminder about attention management. Not every quiet gap in the day needs to be filled with upskilling, podcasts, or side work. When every spare moment is stuffed with fresh stimulation, we gradually lose the ability to observe, rest properly, think deeply, and be fully present with whatever is in front of us. Looking busy and optimized isn&amp;rsquo;t the same as living intentionally; leaving blank space in your day is part of sustainable productivity, especially in engineering roles already fragmented by constant context switching.&lt;/p&gt;
&lt;h2 id="predicting-ai-job-exposure"&gt;&lt;a href="https://www.ben-evans.com/benedictevans/2026/5/24/ai-job-exposure" rel="noopener noreferrer"&gt;Predicting AI job exposure&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benedict Evans critiques efforts to score which professions, companies, or industries are most &amp;ldquo;exposed&amp;rdquo; to AI disruption. In his view, this amounts to predicting the unpredictable, and the simplest sanity check is running the same methodology backward against previous technology waves. Over the past century, we automated accounting with mainframes, databases, spreadsheets, and ERPs—yet the total number of accountants kept growing. When analysis becomes cheap and fast, organizations do far more of it and ask different questions, while new regulations create entire categories of compliance work.&lt;/p&gt;
&lt;p&gt;A second blind spot is that a job&amp;rsquo;s core tasks can stay unchanged while the business model underneath it collapses: the internet didn&amp;rsquo;t automate away the craft of journalism, it destroyed the classified-ad monopoly that funded newsrooms. Third are second-order shocks nobody extrapolates from task lists, like smartphone GPS enabling Uber and reshaping the taxi industry. Deeper still, occupational databases like O*NET cannot capture what a real job actually entails, much like early expert systems failed to capture tacit human expertise. Evans concludes that while high-level frameworks are useful for thinking, granular job-by-job forecasts at this early stage will only be right by accident, because we have no way of knowing whether the exceptions will dwarf the rule.&lt;/p&gt;
&lt;h2 id="choosing-values-for-robust-tests"&gt;&lt;a href="https://testing.googleblog.com/2026/06/choosing-values-for-robust-tests.html" rel="noopener noreferrer"&gt;Choosing Values for Robust Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Radion Khait highlights a subtle testing bug that is remarkably easy to miss: a test passes not because the implementation is correct, but because the test input happens to match the type&amp;rsquo;s default value. In the post&amp;rsquo;s example, a custom map&amp;rsquo;s &lt;code&gt;insert&lt;/code&gt; method forgets to assign the &lt;code&gt;value&lt;/code&gt; parameter and simply default-initializes the entry. A test that inserts &lt;code&gt;0&lt;/code&gt; and asserts that lookup returns &lt;code&gt;0&lt;/code&gt; passes with flying colors, because &lt;code&gt;0&lt;/code&gt; is already the default value for an integer. The result is a false sense of security: the method was called, but nothing proved the input was actually stored.&lt;/p&gt;
&lt;p&gt;From that example, Khait distills three practical rules for choosing test inputs. First, always use non-default values: non-zero numbers, non-empty strings, and enum variants other than the first declared value—changing &lt;code&gt;0&lt;/code&gt; to &lt;code&gt;5&lt;/code&gt; exposes the map bug immediately. Second, where appropriate, test representative inputs across equivalence classes such as empty, missing, &lt;code&gt;null&lt;/code&gt;, boundary values, and inputs that trigger complex branches, optionally pairing with fuzzing for broader coverage. Third, use distinct values for every parameter so tests immediately catch implementations that accidentally reuse an argument or swap parameter order; parameterized tests make it easy to cover multiple input combinations without duplicating test code.&lt;/p&gt;
&lt;h2 id="ai-demands-more-engineering-discipline-not-less"&gt;&lt;a href="https://charity.wtf/p/ai-demands-more-engineering-discipline" rel="noopener noreferrer"&gt;AI demands more engineering discipline. Not less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charity Majors pushes back against a growing temptation: if AI generates code quickly and reasonably well, can we relax code reviews, verification, and engineering rigor? Her answer is the exact opposite. As the cost of generating code plummets, lines of code stop being a precious asset and become a disposable artifact of our current understanding. A software team&amp;rsquo;s true output is shared understanding, and what retains lasting value is everything that tells us whether the system is actually working: requirements, invariants, failure modes, tests, observability, and reproducibility.&lt;/p&gt;
&lt;p&gt;She compares the AI wave to the shift from hand-tended &amp;ldquo;pet&amp;rdquo; servers to immutable infrastructure. Once servers could be torn down and rebuilt at will, engineering discipline didn&amp;rsquo;t vanish—it moved up a level into configuration management, provisioning pipelines, verification, and repeatable operations. Software is undergoing the same shift: when code can be regenerated cheaply, individual lines of code stop being the highest-leverage place to spend review energy, and focus moves to artifacts that specify behavior, architecture, trade-offs, and production outcomes. Human brains were never great at statically verifying code anyway, and non-deterministic AI systems make tracing, testing in production, record-and-replay, and tight feedback loops even more critical. Far from making software less rigorous, AI demands more engineering discipline than ever.&lt;/p&gt;
&lt;h2 id="nine-questions-i-now-ask-in-interviews-that-i-wish-i"&gt;&lt;a href="https://louisedeason.substack.com/p/nine-questions-i-now-ask-in-interviews" rel="noopener noreferrer"&gt;Nine Questions I Now Ask in Interviews That I Wish I&amp;rsquo;d Asked Five Years Ago&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Louise Deason reminds candidates that an interview is a two-way evaluation, even though most people still treat it like a school exam—which conveniently benefits the employer. The &amp;ldquo;do you have any questions for us?&amp;rdquo; segment at the end is the most underutilized part of the process, precisely because interviewers let their guard down and inadvertently reveal how the org actually runs. She shares nine questions designed to force specific, revealing answers: how the most recent promotion on the team happened, what the longest-tenured person in this role is doing now, what the team is genuinely bad at, how the team handled a recent disagreement with leadership, headcount plans for the next year, whether you can meet the people you&amp;rsquo;ll actually work with day to day, what six-month success and failure look like, when the last reorg happened, and why this role is open.&lt;/p&gt;
&lt;p&gt;The real signal lies in how the interviewer responds: whether the answer is concrete, evasive, or hesitant. A clear story about promotion criteria or an honest admission of a team&amp;rsquo;s weak spots signals transparency; conversely, claims that &amp;ldquo;we always agree,&amp;rdquo; reluctance to let you speak with future peers, or an awkward pause when asked why the seat is open are major red flags. Her closing reminder: you are always choosing between differently imperfect options, and any company that gets defensive when asked thoughtful questions doesn&amp;rsquo;t deserve your time.&lt;/p&gt;
&lt;h2 id="agentic-testing-where-agents-fit-in-the-e2e-testing-stack"&gt;&lt;a href="https://slack.engineering/agentic-testing-where-agents-fit-in-the-e2e-testing-stack/" rel="noopener noreferrer"&gt;Agentic Testing: Where Agents Fit in the E2E Testing Stack&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergii Gorbachov at Slack shares findings from over 200 end-to-end test runs powered by AI agents, exploring where agentic testing belongs in the testing stack. Traditional E2E tests enforce a rigid, scripted path through the UI, whereas agentic tests start from a high-level goal: the agent observes the current UI state, decides the next action on the fly, and verifies the outcome. The team benchmarked three approaches—an agent driving Playwright MCP, an agent driving Playwright CLI, and AI-generated deterministic Playwright test scripts—against a staging workspace with synthetic data across two user flows: replying to a thread and search discovery.&lt;/p&gt;
&lt;p&gt;The AI-generated Playwright scripts ran fastest at around 3 minutes, but their failure rate spiked to ~48% on the more complex flow. Using Sonnet 4.5 to run the agent and Opus 4.6 to generate tests, Playwright MCP achieved the lowest failure rate at 0–12%, compared to 12–20% for Playwright CLI, where most failures stemmed from login and navigation hiccups at the execution layer. MCP also required fewer interaction turns because it batches actions and returns updated state in a single round-trip. However, each agentic test run cost $15–$30 and took over 5 minutes, with most of the cost driven by repeatedly re-sending conversation history. Slack&amp;rsquo;s conclusion: deterministic E2E tests remain the backbone for fast CI regression checks, while agentic testing sits as a complementary layer at the top of the testing pyramid—ideal for exploratory testing of complex flows, diagnosing flaky journeys, and reproducing production bugs.&lt;/p&gt;
&lt;h2 id="making-agents-easy-13-lessons-from-forter"&gt;&lt;a href="https://blog.forter.dev/making-agents-easy-13-lessons-from-forters-agentic-ai-sprint/" rel="noopener noreferrer"&gt;Making Agents Easy: 13 Lessons from Forter&amp;rsquo;s Agentic AI Sprint&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Maraney recounts how Forter ran a two-week company-wide sprint to get their entire R&amp;amp;D organization building AI agents. The core thesis isn&amp;rsquo;t that building agents is inherently effortless, but that an organization can systematically remove friction across three layers: tooling, agent runtime infrastructure, and organizational guardrails. On the tooling side, Forter built an internal MCP server called Toolchain: engineers open a web UI, pick and configure the tools they need, and immediately get an API key; adding a new internal tool takes just a declarative YAML file and a thin wrapper. By the end of the two-week sprint, Toolchain had grown to over 90 internal tools. And rather than standing up a complex custom RAG pipeline, they exposed their existing enterprise search engine as an MCP tool.&lt;/p&gt;
&lt;p&gt;The post shares several pragmatic operational lessons as well. Agent builders need full visibility into every raw tool request and response—one Forter incident-response agent appeared to &amp;ldquo;solve&amp;rdquo; an outage brilliantly until traces revealed it had simply read the already-written postmortem doc. For internal human-in-the-loop tools, teams don&amp;rsquo;t need formal eval suites on day one; prioritize tracing and observability first. Bring legal and security in early, enforce permissions in deterministic code rather than prompts, and put token costs on a visible dashboard. Finally, when training teams, tell them to treat an LLM like a bright new-grad intern: broad textbook knowledge, zero institutional context—meaning the responsibility for giving clear instructions rests squarely on the builder.&lt;/p&gt;
&lt;h2 id="agentic-code-review"&gt;&lt;a href="https://addyosmani.com/blog/agentic-code-review/" rel="noopener noreferrer"&gt;Agentic Code Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that as coding agents write code faster and faster, the primary bottleneck in software engineering shifts from writing code to verifying and trusting it. AI can produce mountains of syntactically valid, test-accompanied, plausible-looking code, but human reading comprehension hasn&amp;rsquo;t sped up to match. That makes code review the highest-leverage skill in modern engineering: not merely hunting for typos, but reconstructing intent, assessing blast radius, spreading system knowledge across the team, and deciding whether a change should exist at all. Industry data from 2026 cited in the post shows that while code output has surged, code churn, defects, production incidents, and review wait times have climbed right alongside it.&lt;/p&gt;
&lt;p&gt;There is no single review policy that fits every context. Solo side projects with no users can lean heavily on automated tests and AI review; long-lived production systems handling real users, money, or sensitive data require risk-tiered human review. Osmani recommends keeping pull requests small, stating intent explicitly, requiring concrete proof of verification (such as real test outputs) before human review begins, reading test diffs more closely than implementation diffs, treating deterministic CI as a non-negotiable guardrail, and using AI reviewers as sensors rather than final judges. Humans may no longer read every single generated line, but they still own the merge button, carry accountability for production, and must focus their deepest scrutiny on high-blast-radius changes like auth, billing, security, and privacy.&lt;/p&gt;
&lt;h2 id="i-thought-redis-was-just-a-hashmap"&gt;&lt;a href="https://mukul0x9.pages.dev/blog/memdb/" rel="noopener noreferrer"&gt;I Thought Redis Was Just a HashMap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mukul Makwana starts from a deceptively simple question: how different is Redis or Memcached from a global hash map supporting &lt;code&gt;set&lt;/code&gt;, &lt;code&gt;get&lt;/code&gt;, and &lt;code&gt;del&lt;/code&gt;? To find out, he built a minimal in-memory database from scratch in Go. Version one wrapped Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt;, accepted commands over TCP, and spawned one goroutine per client connection. The bottleneck appeared immediately as soon as multiple goroutines read and wrote concurrently: the map needed synchronization, and a single global mutex forced every operation to wait in line.&lt;/p&gt;
&lt;p&gt;To fix that, Makwana replaced the built-in map with a two-array arena design: &lt;code&gt;bucket_array&lt;/code&gt; stores offsets while &lt;code&gt;data_array&lt;/code&gt; packs metadata, keys, values, and next-entry offsets for collision chaining in contiguous byte slices. To reduce lock contention, the keyspace is partitioned into shards, each with its own arrays and &lt;code&gt;RWMutex&lt;/code&gt;, while a background goroutine handles shard resizing when load factors climb. Because &lt;code&gt;data_array&lt;/code&gt; is append-only, deletes simply mark a tombstone bit, and a compaction pass rebuilds the shard once dead bytes cross a threshold—at the cost of locking that shard during compaction. Benchmarking &lt;code&gt;SET&lt;/code&gt; workloads showed Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt; still winning on raw throughput and stop-the-world pause times, but the custom pointer-free arena slashed concurrent GC mark time from ~113 ms down to 7.8 ms. Even then, this toy engine still lacks persistence, eviction policies, crash recovery, and replication—the exact things that make real Redis a serious piece of engineering.&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 #115</title><link>https://miti99.com/en/post/2026/07/02/</link><pubDate>Thu, 02 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #115.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-experiments-explained"&gt;&lt;a href="https://www.alexedwards.net/blog/go-experiments-explained" rel="noopener noreferrer"&gt;Go Experiments Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards explains the experimental feature mechanism Go ships in each release: sometimes a new standard library package like &lt;code&gt;testing/synctest&lt;/code&gt;, sometimes a compiler or runtime change like a new garbage collector, and more rarely a language behavior change like loop variable scoping before it became the default in Go 1.22. The goal is to gather real-world feedback before locking a feature in; if it causes problems or draws pushback, it can be revised or dropped entirely. The typical lifecycle starts disabled by default, flips to enabled by default after a release or two (often with a transition period allowing opt-out), and eventually retires the flag—though exceptions happen: &lt;code&gt;Arenas&lt;/code&gt; was put on indefinite hold after negative feedback, while Swiss tables went straight to default.&lt;/p&gt;
&lt;p&gt;Because there is no official status page tracking experiments, Edwards compiled a reference table for Go 1.26 from &lt;code&gt;go doc goexperiment.Flags&lt;/code&gt;, the &lt;code&gt;internal/buildcfg&lt;/code&gt; source, and release notes. To use them, pass comma-separated lowercase names in the &lt;code&gt;GOEXPERIMENT&lt;/code&gt; environment variable to enable features, or prefix a name with &lt;code&gt;no&lt;/code&gt; to disable it, across &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go test&lt;/code&gt;. For everyday Go developers, the most notable flags are &lt;code&gt;GreenTeaGC&lt;/code&gt; and &lt;code&gt;Dwarf5&lt;/code&gt; (already enabled by default, so worth knowing how to disable if issues arise), &lt;code&gt;JSONv2&lt;/code&gt;, &lt;code&gt;GoroutineLeakProfile&lt;/code&gt; for catching leaked goroutines, &lt;code&gt;RuntimeSecret&lt;/code&gt; for code handling sensitive data, and &lt;code&gt;RuntimeFreegc&lt;/code&gt;. One important caveat: experiments fall outside Go&amp;rsquo;s compatibility promise, so use them to test, benchmark, and give feedback rather than relying on them prematurely in production.&lt;/p&gt;
&lt;h2 id="low-level-network-optimizations-socket-options-that-matter"&gt;&lt;a href="https://goperf.dev/02-networking/low-level-optimizations/" rel="noopener noreferrer"&gt;Low-Level Network Optimizations: Socket Options That Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This entry from the Go Optimization Guide examines socket options that directly impact latency and throughput in Go network applications. Operating system defaults prioritize safety and broad compatibility, meaning under heavy load they often become bottlenecks well before CPU or memory. &lt;code&gt;TCP_NODELAY&lt;/code&gt; disables Nagle&amp;rsquo;s algorithm so small packets are sent immediately at the cost of higher bandwidth overhead; Go enables this by default on &lt;code&gt;TCPConn&lt;/code&gt;. &lt;code&gt;SO_REUSEPORT&lt;/code&gt; lets multiple processes or threads bind to the same port while the kernel distributes incoming connections across separate queues, reducing lock contention and scaling across CPU cores. Receive and send buffer sizes (&lt;code&gt;SO_RCVBUF&lt;/code&gt; and &lt;code&gt;SO_SNDBUF&lt;/code&gt;) should roughly match the bandwidth-delay product: too small increases syscalls and caps throughput, while too large wastes memory and inflates latency via bufferbloat.&lt;/p&gt;
&lt;p&gt;For TCP keepalives, OS defaults are very conservative; common production settings wait 30–60 seconds, probe every 10–15 seconds, and retry 3–5 times, though tuning them too aggressively increases traffic and risks false drops on congested links. In Go, &lt;code&gt;SetKeepAlivePeriod&lt;/code&gt; only controls the initial idle time; starting in Go 1.23, &lt;code&gt;SetKeepAliveConfig&lt;/code&gt; lets you configure Interval and Count without dropping down to raw syscalls. &lt;code&gt;SOMAXCONN&lt;/code&gt; governs the listener backlog queue and is tuned at the OS level via &lt;code&gt;sysctl&lt;/code&gt;. To apply socket options at the right moment—before the socket is bound—use the &lt;code&gt;Control&lt;/code&gt; callback on &lt;code&gt;net.ListenConfig&lt;/code&gt; with &lt;code&gt;syscall.RawConn&lt;/code&gt;. The overarching advice: change one setting at a time, test under realistic load, and rely on measurements rather than copy-pasting configs from elsewhere.&lt;/p&gt;
&lt;h2 id="when-is-100-vibe-coding-ok-"&gt;&lt;a href="https://dev.to/realvorl/when-is-100-vibe-coding-ok--38p" rel="noopener noreferrer"&gt;When Is 100% Vibe Coding OK ?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Viorel PETCU opens with the frustration of spending hours reviewing &amp;ldquo;vibe-written&amp;rdquo; specifications: they read smoothly on the surface but say almost nothing concrete and cannot be applied to an existing system. The author isn&amp;rsquo;t against vibe coding—in fact, he uses it regularly for one-off scripts, throwaway charts, quick parsers, or docs nobody has to maintain, where speed matters more than rigor. Once software needs long-term maintenance, however, the equation changes completely.&lt;/p&gt;
&lt;p&gt;His motivating example is a wooden puzzle of 25 identical pentacube pieces that must pack a &lt;code&gt;5×5×5&lt;/code&gt; cube. After failing to solve it by hand, he used Go and ChatGPT to write a solver: the initial struggle wasn&amp;rsquo;t the algorithm, but the domain representation—coordinate conventions, slice notation, piece rotations, and naming. Once the model stabilized, the rest was classic brute-force recursion with backtracking, and modern hardware was fast enough that no further optimization was needed. Within about two hours, the project evolved into a general solver complete with OBJ/MTL export for viewing in Blender. Crucially, the author was able to push past hallucinated constraints, wrong assumptions, and buggy code because he already knew for a fact that the puzzle had a physical solution. His conclusion: 100% vibe coding is fine when a human holds the invariants, the constraints are real, and the output is verifiable; if the requirements themselves are just vibes, the system has nothing solid to converge on.&lt;/p&gt;
&lt;h2 id="self-calling-executables"&gt;&lt;a href="https://log.pfad.fr/2026/self-calling-executable/" rel="noopener noreferrer"&gt;Self-calling executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olivier introduces the &amp;ldquo;self-calling executable&amp;rdquo; pattern: a running program spawns another instance of itself, directly or indirectly, to take on a different role. The first use case is black-box testing a &lt;code&gt;main&lt;/code&gt; function when the codebase relies on global state that causes in-process tests to interfere with one another. A test invokes the test binary itself via &lt;code&gt;os.Args[0]&lt;/code&gt; along with an environment variable like &lt;code&gt;TEST_MAIN&lt;/code&gt;; inside &lt;code&gt;TestMain&lt;/code&gt;, if that variable is set, the binary runs the real entrypoint instead of the test runner, isolating each invocation inside a fresh child process.&lt;/p&gt;
&lt;p&gt;The second use case is integrating with external tools, illustrated by jjui, a terminal UI for Jujutsu. The &lt;code&gt;ssh&lt;/code&gt; command uses the &lt;code&gt;SSH_ASKPASS&lt;/code&gt; environment variable to invoke an external helper when it needs a passphrase; jjui points &lt;code&gt;SSH_ASKPASS&lt;/code&gt; back at itself so that when &lt;code&gt;ssh&lt;/code&gt; prompts for a password, the grandchild process connects back to the main jjui process over a Unix domain socket (with the PID embedded in the path so multiple sessions can run concurrently), forwards the prompt, collects the user&amp;rsquo;s input, and prints it to stdout for &lt;code&gt;ssh&lt;/code&gt;. Because this handles sensitive credentials, the author adds two safeguards: each child receives a random token it must present on connect, and the main process walks the connecting client&amp;rsquo;s ancestor PID chain to verify lineage. Downsides include harder debugging, risk of infinite recursion if environment variables are misconfigured, and the Go race detector sleeping for 1 second on every process exit—which once stretched Forgejo&amp;rsquo;s integration suite from 45 minutes to over 2 hours, fixable via &lt;code&gt;GORACE=&amp;quot;atexit_sleep_ms=0&amp;quot;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="modern-engineering-values"&gt;&lt;a href="https://cpojer.net/posts/modern-engineering-values" rel="noopener noreferrer"&gt;Modern Engineering Values&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christoph Nakazawa shares that he now rarely writes code by hand: projects like Vite+, fate, and Athena Crisis are largely written by coding agents, primarily via Codex CLI. His workflow is to have the agent propose a plan and ask clarifying questions before executing, require a failing test before fixing a bug, run several automated review passes, and only then review the diff himself. When writing code is no longer the bottleneck, discussing and reviewing code becomes the limiting factor.&lt;/p&gt;
&lt;p&gt;From there, the post proposes a set of engineering values for the agentic era. Strong ownership: agents amplify engineers with deep product understanding just as much as they amplify noise from people lacking context, meaning effective teams will be small—around two to three people—with clear boundaries, and code review will focus on alignment rather than nitpicking individual lines. Good taste to know what is actually worth building. Tight guardrails and fast feedback loops—linters, automated tests, and tools that operate only on changed files—because working with agents is like onboarding a brand-new hire with zero context on every prompt. Keeping context inside the repo rather than scattered across docs, chat threads, or tribal memory. Owning your stack instead of pulling in heavy third-party dependencies, since agents have drastically lowered the cost of building in-house. As for management, he believes the role will become increasingly technical: as execution becomes cheap, judgment becomes the bottleneck.&lt;/p&gt;
&lt;h2 id="building-software-is-learning"&gt;&lt;a href="https://registerspill.thorstenball.com/p/building-software-is-learning" rel="noopener noreferrer"&gt;Building Software Is Learning&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball publishes an internal note sent to the Amp team on why building new software is always a learning process. The idealized sequence—&amp;ldquo;we need this feature,&amp;rdquo; &amp;ldquo;I built it,&amp;rdquo; &amp;ldquo;that&amp;rsquo;s exactly what I wanted&amp;rdquo;—almost never happens without a detailed spec; reality usually looks more like &amp;ldquo;that&amp;rsquo;s not what I meant,&amp;rdquo; &amp;ldquo;there are three ways to do this, which one do we want?&amp;rdquo;, or &amp;ldquo;I tried it and I don&amp;rsquo;t like how it feels.&amp;rdquo; That is because people only truly understand what they are building while building it, and avoiding that discovery entirely would require specifying every detail up front—which is just programming by another name.&lt;/p&gt;
&lt;p&gt;The good news is that you can shrink the gap between a confident &amp;ldquo;I&amp;rsquo;ll build it&amp;rdquo; and contact with reality. Instead of disappearing for four weeks, build a prototype in an hour, write a spec in thirty minutes, break the work down and ship a piece every day, cut scope to isolate the unknowns, record a fake demo video, write the release announcement first, or draft README examples to test an API design. Feedback can come from CI, teammates, users, or yourself dogfooding the feature. Ball adds two practical warnings: a prototype riddled with obvious bugs will only get you bug reports instead of useful design feedback, and keeping a branch alive for three weeks before merging 27 commits at once means when CI breaks, you have 27 potential culprits. The question to keep asking is how to get feedback as early and as often as possible so you can learn faster.&lt;/p&gt;
&lt;h2 id="you-must-fix-your-asserts"&gt;&lt;a href="https://kristoff.it/blog/fix-your-asserts/" rel="noopener noreferrer"&gt;You Must Fix Your Asserts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro argues against the habit of disabling assertions in production, using Zig as context. An assertion is a line of code stating a program truth—a precondition, postcondition, or invariant; if the type system can express the constraint, use types, and otherwise assertions catch programming bugs, often more effectively than unit tests when paired with fuzzing. In Zig, &lt;code&gt;std.debug.assert&lt;/code&gt; is built on &lt;code&gt;unreachable&lt;/code&gt;: in checked build modes like Debug or ReleaseSafe, a violated assertion panics; in ReleaseFast or ReleaseSmall, the compiler treats the assertion as an assumed fact for optimization, meaning a false assertion leads to unpredictable undefined behavior. Unlike C/C++, Zig&amp;rsquo;s assert is a regular function rather than a macro, so its argument expression is always evaluated.&lt;/p&gt;
&lt;p&gt;According to Cro, you have three choices: keep assertions active as runtime checks, let the compiler optimize around them and accept the risk, or strip them out—and the third option is the worst. Disabling assertions means that when the &amp;ldquo;impossible&amp;rdquo; happens, the program keeps running on broken assumptions, silently diverging from its spec while stripping away the very signal that would have caught it. Worse, future maintainers will write new code trusting those false assertions, allowing vulnerabilities to creep in unnoticed. He points to TigerBeetle keeping assertions enabled in production and Ghostty shipping ReleaseFast builds. The takeaway: fix broken assertions, gate genuinely expensive checks behind debug-only flags, log instead of crashing where appropriate, and choose build modes based on your risk model rather than erasing error signals.&lt;/p&gt;
&lt;h2 id="the-software-engineering-books-i-keep-recommending"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/best-software-engineering-books-2026" rel="noopener noreferrer"&gt;The Software Engineering Books I keep recommending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr. Milan Milanović shares the software engineering books he recommends most often, noting that reading gives him both breadth and depth in technical discussions and decision-making—and in the AI era, helps him evaluate and steer AI tools more effectively. Rather than presenting a one-size-fits-all &amp;ldquo;must-read&amp;rdquo; list, he groups the books by the specific problem a reader is facing, arguing that the right question isn&amp;rsquo;t &amp;ldquo;what should I read?&amp;rdquo; but &amp;ldquo;where am I currently stuck?&amp;rdquo; Most of the picks aren&amp;rsquo;t tied to specific frameworks, so their lessons age well.&lt;/p&gt;
&lt;p&gt;For coding mindset, he highlights &lt;code&gt;The Pragmatic Programmer&lt;/code&gt;, &lt;code&gt;Clean Code&lt;/code&gt; (noting some rules are dated), and &lt;code&gt;A Philosophy of Software Design&lt;/code&gt;, the book he re-reads most often. Architecture covers &lt;code&gt;Fundamentals of Software Architecture&lt;/code&gt;, &lt;code&gt;Software Architecture: The Hard Parts&lt;/code&gt;, and &lt;code&gt;Domain-Driven Design Quickly&lt;/code&gt;; systems and data feature the second edition of &lt;code&gt;Designing Data-Intensive Applications&lt;/code&gt; alongside the more approachable &lt;code&gt;Understanding Distributed Systems&lt;/code&gt;. The AI section pairs &lt;code&gt;The Hundred-Page Language Models Book&lt;/code&gt; on how language models work with Chip Huyen&amp;rsquo;s &lt;code&gt;AI Engineering&lt;/code&gt; on building real-world AI applications. Rounding out the list are &lt;code&gt;The Art of Unit Testing&lt;/code&gt; for testing, &lt;code&gt;Accelerate&lt;/code&gt; (with the four DORA metrics) and &lt;code&gt;Refactoring&lt;/code&gt; for development workflow, and &lt;code&gt;The Software Engineer's Guidebook&lt;/code&gt; and &lt;code&gt;Deep Work&lt;/code&gt; for career growth. He also mentions his own new book on laws in software engineering.&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 #114</title><link>https://miti99.com/en/post/2026/07/01/</link><pubDate>Wed, 01 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #114.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-errors-are-a-story-most-teams-lose-the-plot"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-errors/" rel="noopener noreferrer"&gt;Go errors are a story, most teams lose the plot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Robin Siep examines a fundamental difference in how Go handles errors: unlike Java and many other languages, Go errors do not automatically carry stack traces. Instead, developers wrap errors with context at each layer they pass through—such as &lt;code&gt;fmt.Errorf(&amp;quot;unable to get user: %w&amp;quot;, err)&lt;/code&gt;—ultimately producing a chain like &lt;code&gt;unable to get user: failed to query users table: connection refused&lt;/code&gt;. The author calls this a &amp;ldquo;logical trace&amp;rdquo;: when maintained well, it is easier to read than a multi-dozen-line stack trace and stays intact even when errors cross channels, goroutines, or other handoff boundaries where call stacks can get lost.&lt;/p&gt;
&lt;p&gt;The catch is that a logical trace requires relentless discipline from the entire team. Forget to wrap an error at just one call site, and your logs may be left with a bare &lt;code&gt;connection refused&lt;/code&gt;; and much like code comments, an error-wrapping message written two years ago can drift out of date or become misleading. In the author&amp;rsquo;s observation, most teams fail to keep up with this maintenance burden, leaving production errors without enough context to diagnose root causes. The proposed middle ground is to attach a stack trace the moment the application creates an error or first receives one from a third-party library, and then add manual context only when it genuinely clarifies the problem. That way, the stack trace serves as a cheap, always-present fallback. Implementing this yourself is straightforward, or you can reach for Dave Cheney&amp;rsquo;s &lt;code&gt;pkg/errors&lt;/code&gt; or &lt;code&gt;cockroachdb/errors&lt;/code&gt; if you want an actively maintained library.&lt;/p&gt;
&lt;h2 id="the-last-technical-interview"&gt;&lt;a href="https://steve-yegge.medium.com/the-last-technical-interview-bc13ddcf4564" rel="noopener noreferrer"&gt;The Last Technical Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Yegge—who has conducted technical interviews for nearly 35 years, serving as an Amazon Bar Raiser and a Google Hiring Committee member—argues that the traditional technical interview loop is reaching the end of the line. The model of cramming several one-hour interviews into a single day has barely changed in fifty years despite terrible results: interviewers routinely disagree with one another, interview scores barely correlate with actual on-the-job performance, and resumes are becoming increasingly useless now that AI writes them. His most memorable anecdote comes from Google, where recruiting handed the hiring committee a batch of anonymized interview packets disguised as a &amp;ldquo;calibration exercise&amp;rdquo;; the committee voted to reject roughly two-thirds of them, only to learn afterward that the packets were their own historical interview files.&lt;/p&gt;
&lt;p&gt;According to Yegge, the strongest hiring signal has always come from real work—internships, six-month co-ops at Geoworks, or contract-to-hire trials—so it is time to stop &amp;ldquo;simulating work.&amp;rdquo; A new &amp;ldquo;campfire&amp;rdquo; model is emerging in San Francisco: inviting candidates for a paid multi-day stint working on real code, real requirements, and alongside the real team. To make this fair, every stint should &amp;ldquo;count twice&amp;rdquo;: the company gets high-signal evaluation and real output, while the candidate walks away with a durable, company-verified record of what they built and how well they performed, whether or not they receive an offer. Such a system only works if those &amp;ldquo;stamps of approval&amp;rdquo; are issued honestly.&lt;/p&gt;
&lt;h2 id="guidelines-for-respectful-use-of-ai"&gt;&lt;a href="https://www.elidedbranches.com/2026/05/guidelines-for-respectful-use-of-ai.html" rel="noopener noreferrer"&gt;Guidelines for Respectful Use of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Camille Fournier argues that many leaders view AI policies purely through the lens of security, compliance, or cost, overlooking how teams actually work together when AI enters the picture. AI lets an individual generate far more output, but if that person doesn&amp;rsquo;t review it themselves, the quality-control burden simply gets pushed onto teammates and overall team productivity drops. Her first rule is therefore simple: never ask someone else to read or review something you haven&amp;rsquo;t read yourself. This applies to code and even more so to documents, since the context in your head while chatting with an AI may be completely absent from the final text; if you cannot explain and discuss a document yourself, you shouldn&amp;rsquo;t send it out.&lt;/p&gt;
&lt;p&gt;Her second rule is &amp;ldquo;shorter is better&amp;rdquo;: AI-generated code often reads like verbose tutorial code, pull requests balloon to thousands of lines, three-page documents turn into 10-to-20-page essays, and Slack messages and emails become walls of text. She suggests a litmus test: if this change breaks at 3 a.m. and every AI tool is down, can you debug it yourself? For long documents, put a concise summary of the key points right at the top; if you find yourself writing a massive email to explain something, you should probably hop on a call instead. Ultimately, AI is not an excuse to turn off your brain or your empathy: use the productivity gains to ship simpler, better-tested work.&lt;/p&gt;
&lt;h2 id="software-after-ai"&gt;&lt;a href="https://tomtunguz.com/harnessing-ai/" rel="noopener noreferrer"&gt;Software After AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz argues that the familiar software era—where SaaS products manage databases through fixed workflows—is giving way to the era of the &amp;ldquo;harness&amp;rdquo;: the surrounding layer that turns a raw LLM into a reliable agent. He compares an LLM to a wild horse that needs to be broken in. When every company has access to the exact same foundation models, competitive advantage no longer lives in the model itself, but in whoever builds the best harness.&lt;/p&gt;
&lt;p&gt;The post outlines seven components of an AI harness. Context and memory require domain-specific retrieval alongside a &amp;ldquo;context database&amp;rdquo; capturing how a business actually operates. Tools and actions are exposed through a registry with parameter validation and approval gates for sensitive operations, with MCP acting as the connective tissue. Orchestration is the think-act-observe-repeat loop, complete with planning, subagents, and stopping conditions. State and persistence allow a mid-flight failure to resume from the last verified checkpoint (for instance, finishing step 7 and resuming at step 8) instead of starting over from scratch. Sandboxing isolates the execution environment. Observability and governance—traces, logs, evals, and human-in-the-loop approvals for high-stakes decisions—turn a demo into a production system. Finally, cost and workflow optimization decide which steps belong in deterministic code and which call for large or small models. Frontier labs will win the markets they prioritize, but thousands of vertical markets remain wide open for startups.&lt;/p&gt;
&lt;h2 id="design-patterns-are-dead-long-live-design-patterns"&gt;&lt;a href="https://medium.com/google-cloud/design-patterns-are-dead-long-live-design-patterns-b2c2602fbdc4" rel="noopener noreferrer"&gt;Design Patterns Are Dead. Long Live Design Patterns.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christina Lin, a veteran developer, asks whether classic design patterns still matter when AI writes most of the code. Patterns like Singleton, Factory, and Observer were created for human comprehension rather than compilers, so at first she wondered if they had become obsolete. Once a codebase grows large enough, however, AI starts to ramble because it has limits of its own: Chroma&amp;rsquo;s research across 18 models showed reliability degrading as input length grows (&amp;ldquo;context rot&amp;rdquo;), with the drop-off varying by model. As a result, design patterns aren&amp;rsquo;t dead—they&amp;rsquo;ve been promoted from implementation blueprints to ways of compressing intent into prompts and enforcing architectural guardrails around probabilistic models.&lt;/p&gt;
&lt;p&gt;Lin reclassifies patterns around a single question: is this pattern here to help humans read code, or to constrain AI? Patterns that merely patched missing language features, like Iterator or Prototype, are dead; speculative abstractions built &amp;ldquo;just in case&amp;rdquo; should also be pared back now that code is cheap and intent is expensive. Conversely, three patterns matter more than ever: Adapter forces AI outputs into strict schemas before touching the database and feeds validation errors back for self-correction; Decorator wraps retries, timeouts, and token-cost tracking around core logic; and Facade hides complex multi-step agent workflows behind a clean, auditable interface. The unifying principle is treating AI output as untrusted input: isolate it, validate at the boundary, and trust it only once proven valid.&lt;/p&gt;
&lt;h2 id="merge-intervals"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/merge-intervals-89l" rel="noopener noreferrer"&gt;Merge Intervals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh walks through Merge Intervals, a classic interview problem: given an array of &lt;code&gt;[start, end]&lt;/code&gt; intervals, merge all overlapping intervals and return the disjoint result. At first glance it looks like a simulation problem, and the brute-force approach checks every subsequent interval to extend the current end point in &lt;code&gt;O(N²)&lt;/code&gt; time. The key insight is that once intervals are sorted by start time, any overlapping intervals are guaranteed to sit adjacent to one another, so you only ever need to compare the current interval against the most recently merged one.&lt;/p&gt;
&lt;p&gt;That makes the optimal algorithm clean and compact: sort by &lt;code&gt;start&lt;/code&gt; and scan left to right; if the end of the last interval in the result list is smaller than the current interval&amp;rsquo;s start, append the current interval as a new entry; otherwise, update the last interval&amp;rsquo;s end to the maximum of both ends. For input &lt;code&gt;[[1,3],[2,6],[8,10],[15,18]]&lt;/code&gt;, this produces &lt;code&gt;[[1,6],[8,10],[15,18]]&lt;/code&gt;. Overall time complexity is &lt;code&gt;O(N log N)&lt;/code&gt; due to sorting, while the linear scan takes &lt;code&gt;O(N)&lt;/code&gt;. The author also shares interview tips: clearly explain why sorting makes overlapping intervals contiguous, and remember the &amp;ldquo;sort first, then sweep left to right&amp;rdquo; pattern for related problems like Insert Interval, Meeting Rooms, and Non-overlapping Intervals.&lt;/p&gt;
&lt;h2 id="best-time-to-buy-and-sell-stock"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/best-time-to-buy-and-sell-stock-3792" rel="noopener noreferrer"&gt;Best Time to Buy and Sell Stock&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh follows up with another classic LeetCode problem, Best Time to Buy and Sell Stock: given an array of daily stock prices where you may buy once and sell once on a later day, find the maximum profit. For &lt;code&gt;[7,1,5,3,6,4]&lt;/code&gt;, buying at 1 and selling at 6 yields a profit of 5. The brute-force approach treats every day as a buy day, checks every subsequent sell day, and tracks the maximum profit—correct, but &lt;code&gt;O(N²)&lt;/code&gt; because it evaluates far too many redundant buy-sell pairs.&lt;/p&gt;
&lt;p&gt;The key observation is that on any given day, you don&amp;rsquo;t need to remember every prior price—only the lowest price seen so far, because the best profit you could make by selling today is today&amp;rsquo;s price minus that historical minimum. The author notes that he initially considered a dynamic programming array &lt;code&gt;dp[i]&lt;/code&gt;, before realizing that the minimum price is the only state that matters, collapsing the array into two scalar variables: &lt;code&gt;minPrice&lt;/code&gt; and &lt;code&gt;maxProfit&lt;/code&gt;. A single pass that computes today&amp;rsquo;s potential profit, updates the best answer, and updates the running minimum achieves &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space. This is the classic &amp;ldquo;prefix minimum&amp;rdquo; pattern: whenever a problem asks for a maximum profit, maximum difference, or future outcome relative to past values, think about maintaining a running minimum or maximum during a single sweep.&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 #113</title><link>https://miti99.com/en/post/2026/06/24/</link><pubDate>Wed, 24 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #113.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="migrating-from-go-to-rust"&gt;&lt;a href="https://corrode.dev/learn/migration-guides/go-to-rust/" rel="noopener noreferrer"&gt;Migrating from Go to Rust&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthias Endler writes a comprehensive guide for backend teams considering migrating services from Go to Rust. The central message isn&amp;rsquo;t &amp;ldquo;Rust is always faster than Go,&amp;rdquo; but that Rust pushes many classes of risk into the type system so the compiler catches them before production: &lt;code&gt;nil&lt;/code&gt; values, error handling, data races, resource lifetimes, and ownership. Go optimizes for team velocity—fast compile times, a strong standard library, and easy-to-use goroutines. Rust trades that for a stricter compiler, no GC, &lt;code&gt;Result&lt;/code&gt;, &lt;code&gt;Option&lt;/code&gt;, traits, and &lt;code&gt;Send&lt;/code&gt;/&lt;code&gt;Sync&lt;/code&gt; checks. Familiar Go habits have to be remapped: &lt;code&gt;if err != nil&lt;/code&gt; becomes &lt;code&gt;Result&lt;/code&gt; with &lt;code&gt;?&lt;/code&gt;, &lt;code&gt;nil&lt;/code&gt; becomes &lt;code&gt;Option&lt;/code&gt;, interfaces become traits, and goroutines become tasks when genuinely needed.&lt;/p&gt;
&lt;p&gt;The most practical section covers migration strategy: don&amp;rsquo;t rewrite everything at once. Start with a hot path, worker, or clearly bounded service, keep the existing API contract, and shift traffic gradually endpoint by endpoint through a gateway using the strangler pattern. While &lt;code&gt;cgo&lt;/code&gt; works, it is often more complex than splitting the Rust portion into a separate service. The author is also candid about the costs: the borrow checker makes the first month rough, compile times are slower, async function coloring is annoying, and parts of the ecosystem are smaller. There is no need to abandon Go entirely: Go remains a great fit for Kubernetes tooling, CLIs, and &amp;ldquo;boring&amp;rdquo; glue services, while Rust is worth the investment for foundational services where reliability, P99 latency, and bugs like nil dereferences or data races carry higher operational costs than the learning and build overhead.&lt;/p&gt;
&lt;h2 id="ai-engineering-for-developers"&gt;&lt;a href="https://www.lucavallin.com/blog/ai-engineering-for-developers" rel="noopener noreferrer"&gt;AI Engineering for Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Luca Cavallin writes a deep-dive guide to AI engineering for developers already comfortable with backends, HTTP, queues, Kubernetes, and production operations. His main argument: when bringing LLMs into a product, the model is not the whole product; what actually creates value is the system around it—prompts, RAG, evals, agents, inference, observability, security, and cost controls. That makes the discipline much closer to backend engineering than model training. Because AI outputs are non-deterministic and can shift across models, prompts, or data, a working demo isn&amp;rsquo;t enough to ship: you need eval datasets, regression checks on every prompt or model change, canary rollouts, and monitoring from day one.&lt;/p&gt;
&lt;p&gt;The article progresses from fundamentals to practical execution: selecting models by task, cost, and latency; exhausting prompt engineering before reaching for RAG; treating RAG primarily as a search problem where hybrid search, rerankers, chunking strategy, and source citations matter more than stuffing more context; fine-tuning only after prompting and RAG hit their ceiling; and optimizing inference through caching, batching, and model routing. Agents are framed as tool-calling loops that require strict schemas, narrow permissions, end-to-end tracing, and human approval gates for risky actions. The production section emphasizes guardrails, dedicated CI/CD pipelines for prompt and model changes, per-feature cost attribution, and treating every agent as a service with its own identity, least-privilege access, and audit logs.&lt;/p&gt;
&lt;h2 id="the-invisible-engineering-behind-lambdas-network"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/04/the-invisible-engineering-behind-lambdas-network.html" rel="noopener noreferrer"&gt;The invisible engineering behind Lambda’s network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on All Things Distributed recounts nearly a decade of networking optimizations behind AWS Lambda—the kind of &amp;ldquo;invisible&amp;rdquo; engineering customers only notice because functions start faster and more reliably. The original bottleneck was cold starts when Lambda connected to a customer VPC: beyond spinning up a Firecracker microVM and initializing the runtime, the system had to establish a private network path into the customer&amp;rsquo;s VPC, with Geneve tunnel creation sitting right on the hot path. Rather than maintaining custom kernel patches, the Lambda team turned to eBPF: pre-creating tunnels with a dummy VNI and overwriting the packet header once the real VNI arrived, cutting tunnel setup latency from ~150ms to 200 microseconds.&lt;/p&gt;
&lt;p&gt;Even more instructive is how they scaled to 4,000 networks per worker. Instead of creating tap devices, veth pairs, namespaces, and routing rules on every function invocation, they pre-allocated everything at worker startup, turning a load-variable cost into a one-time fixed cost. They replaced stateful NAT with stateless eBPF packet rewriting, cutting NAT setup latency 100x; collapsed over 125,000 iptables rules in the root namespace down to 144 static rules by moving per-slot rules into their respective namespaces; and reduced RTNL lock contention by reordering network creation and attaching eBPF programs in batches. At scale, iptables rules, conntrack, or a single kernel lock can all become bottlenecks. The result is a unified topology serving both traditional workloads and SnapStart, boosting snapshot network throughput 20x and getting repackaged for reuse in Aurora DSQL.&lt;/p&gt;
&lt;h2 id="selective-test-execution-at-stripe-fast-ci-for-a-50m-line-ruby-monorepo"&gt;&lt;a href="https://stripe.dev/blog/selective-test-execution-at-stripe-fast-ci-for-a-50m-line-ruby-monorepo" rel="noopener noreferrer"&gt;Selective Test Execution at Stripe: Fast CI for a 50M-line Ruby monorepo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aditya Anchuri describes how Stripe keeps CI fast for a ~50-million-line Ruby monorepo containing nearly 100,000 test files and 1.2 million test targets. Running the entire suite sequentially would take roughly four months, while Stripe runs around 50,000 builds per week. Their Selective Test Execution (STE) system solves this by running an average of just ~5% of the test suite per build (with a median under 0.5%), consuming less than 10% of the compute required by a run-everything strategy.&lt;/p&gt;
&lt;p&gt;What makes Stripe&amp;rsquo;s approach clever is that they don&amp;rsquo;t attempt static dependency analysis for Ruby, where metaprogramming, dynamic dispatch, configuration files, and code generation make static analysis either miss dependencies or become overly conservative. Instead, they observe runtime behavior: an internal C++ library injected via &lt;code&gt;LD_PRELOAD&lt;/code&gt; intercepts every file open, associates read files with the currently executing test, and propagates tracking across child processes. The &lt;code&gt;open&lt;/code&gt; path writes only minimal logs, keeping aggregation and indexing off the hot path. Those logs are compiled into a roaring bitmap index mapping changed files to required tests, storing roughly three billion data points while remaining fast to query. File changes are detected using &lt;code&gt;hashdeep&lt;/code&gt; so generated files are covered alongside git-tracked files. STE also relies on reproducible baseline data and practical CI safety nets: always re-running currently failing tests, always running tests that glob the filesystem, handling linters via changed-file lists, and storing metadata in MongoDB with Monotonic Revision IDs to quickly select baselines in commit order.&lt;/p&gt;
&lt;h2 id="being-oncall-taught-me-everything"&gt;&lt;a href="https://yaoyue.org/blog/2026-oncall/" rel="noopener noreferrer"&gt;Being oncall taught me everything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yao Yue looks back on 7.5 years of being on call for Twitter&amp;rsquo;s distributed caching layer—the highest-throughput service and the one involved in the most severe site-wide outages. The post doesn&amp;rsquo;t romanticize on-call life, but argues that living alongside production is what shaped the author&amp;rsquo;s mindset as an infrastructure engineer. On-call teaches you that at scale, predictability matters more than being fast in the average case, tail latency matters more than the median, simple and clear architecture is a lifeline during a crisis, and operational excellence (deep observability, consistent configuration, automation readiness, sensible defaults) comes from up-front design rather than frantic patching two weeks before launch.&lt;/p&gt;
&lt;p&gt;Even more memorable are the human lessons. Periodically restarting Memcached to prevent site-wide cascading failures sometimes triggered incidents of its own, teaching the author to pick low-risk windows, give advance notice, and—most importantly—own mistakes immediately, since that is the fastest way to earn back teammates&amp;rsquo; trust. Many outages were resolved only through doggedly narrowing down possibilities and leaning on colleagues across every layer of the stack: site ops, kernel engineers, upstream service owners, managers, and fellow on-call engineers. The conclusion is blunt: engineers don&amp;rsquo;t truly understand software until they see it run and break in production, and people who write software shouldn&amp;rsquo;t consider themselves above deploying, monitoring, or debugging what they build.&lt;/p&gt;
&lt;h2 id="claude-as-your-performance-analysis-partner"&gt;&lt;a href="https://developers.redhat.com/articles/2026/05/29/claude-your-performance-analysis-partner" rel="noopener noreferrer"&gt;Claude as your performance analysis partner&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Archana Ravindar experiments with using Claude as a partner for Go performance analysis across CPU profiles and execution traces, focusing on the Green Tea garbage collector on POWER10 using the &lt;code&gt;sweet&lt;/code&gt; benchmark suite. Claude&amp;rsquo;s value doesn&amp;rsquo;t lie in immediately generating a working optimization patch, but in rapidly digesting massive, dense artifacts like &lt;code&gt;pprof&lt;/code&gt; outputs, assembly dumps, and trace timelines. For example, Claude pinpointed a hot path in &lt;code&gt;runtime.tryDeferToSpanScan&lt;/code&gt;, spotted an atomic &lt;code&gt;Load8&lt;/code&gt; followed by &lt;code&gt;Or8&lt;/code&gt; pattern, and suggested fusing them into a single &lt;code&gt;Or32&lt;/code&gt; instruction. That experiment actually ran slower, and Claude then helped explain why: false sharing and contention across GC workers—a clear illustration that fewer atomic instructions doesn&amp;rsquo;t automatically mean faster code.&lt;/p&gt;
&lt;p&gt;Claude also proved useful for low-level analysis: cross-referencing assembly to see that the compiler wasn&amp;rsquo;t caching &lt;code&gt;q.class.sizeclass&lt;/code&gt;, ranking GC TODO comments by profile heat, and suggesting patterns to look for in traces such as idle processors during GC, mark assist gaps, overly frequent GC cycles, or prolonged &lt;code&gt;gcMarkDone&lt;/code&gt; phases. The author draws a clear distinction: profiles tell you where cost lives, while traces explain why the system is stalling, especially around GC and scheduling. Still, every hypothesis must be benchmarked, because optimizations tied to hardware architecture, cache lines, instruction sets, or register pressure are easy to get wrong without full context; the best use of AI here is narrowing the search space and building an investigation checklist, not replacing benchmarks.&lt;/p&gt;
&lt;h2 id="things-you-didn"&gt;&lt;a href="https://jon.chrt.dev/2026/04/15/things-you-didnt-know-about-indexes.html" rel="noopener noreferrer"&gt;Things you didn&amp;rsquo;t know about indexes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jon Charter explains Postgres indexes with an approachable analogy: an index is like the index at the back of a book, letting the database locate rows through a sorted structure instead of scanning the entire table. That speed comes with a fundamental trade-off: faster reads mean slower writes. Data modifications (&lt;code&gt;INSERT&lt;/code&gt;, &lt;code&gt;UPDATE&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;) usually have to update indexes as well and incur cleanup overhead; indexes also consume disk space, compete for cache memory, and give the query planner more paths to evaluate. Consequently, &amp;ldquo;index everything&amp;rdquo; is rarely a good strategy.&lt;/p&gt;
&lt;p&gt;The most useful section covers common pitfalls that prevent an index from being used. Composite indexes depend on column order, so the order must match real query patterns: &lt;code&gt;(type_1, type_2)&lt;/code&gt; helps queries filtering on &lt;code&gt;type_1&lt;/code&gt; or both columns, but is generally ineffective when filtering only on &lt;code&gt;type_2&lt;/code&gt; (though PostgreSQL 18&amp;rsquo;s skip scan helps in some cases). Wrapping a column in a function like &lt;code&gt;lower(name)&lt;/code&gt; causes a plain index on &lt;code&gt;name&lt;/code&gt; to be ignored because the database needs a structure sorted by the exact expression &lt;code&gt;lower(name)&lt;/code&gt;; implicit type casts cause the same issue. The right way to verify index usage is running &lt;code&gt;EXPLAIN&lt;/code&gt; or &lt;code&gt;EXPLAIN ANALYZE&lt;/code&gt; to confirm what the planner actually chooses rather than guessing. Finally, the post introduces functional indexes, partial indexes for small slices of data like soft-deleted rows or &lt;code&gt;is_legendary = true&lt;/code&gt;, and covering indexes with &lt;code&gt;INCLUDE&lt;/code&gt; to enable &lt;code&gt;Index Only Scan&lt;/code&gt;.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>