<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>DevOps on miti99</title><link>https://miti99.com/en/tags/devops/</link><description>Recent content in DevOps 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/devops/index.xml" rel="self" type="application/rss+xml"/><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 #109</title><link>https://miti99.com/en/post/2026/06/06/</link><pubDate>Sat, 06 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #109.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-history-of-ides-at-google"&gt;&lt;a href="https://laurent.le-brun.eu/blog/a-history-of-ides-at-google" rel="noopener noreferrer"&gt;A History of IDEs at Google&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurent Le Brun, who spent 12 years working on developer tooling at Google, recounts the journey from a fragmented ecosystem of editors to a single IDE used by nearly the entire company. Back in 2011, when someone asked whether Google should standardize on one IDE, the near-unanimous answer was &amp;ldquo;no&amp;rdquo; — Jeff Dean argued that forcing a whole team onto a single editor was a recipe for misery. The price of that freedom was that every useful integration — Bazel, code search, formatters — had to be rebuilt for every editor. Around 2013, Cider launched as a web-based editor initially meant for quick doc edits, but thanks to a backend capable of indexing Google&amp;rsquo;s massive monorepo, it gradually won over Go and then Java developers.&lt;/p&gt;
&lt;p&gt;In 2020, the team decided to replace Cider&amp;rsquo;s custom frontend with the VS Code core while keeping Google&amp;rsquo;s proprietary backend; Cider V opened to 5,000 engineers in 2021 and accounted for roughly 80% of main-repo development by 2023. Once most engineers shared a single platform, teams had strong incentives to build internal extensions — roughly 100 within two years — and AI features like code completion and automated review-comment resolution could be rolled out company-wide far faster. The takeaway: standardizing tooling creates massive leverage, even if the up-front investment is high and not every company can pull it off.&lt;/p&gt;
&lt;h2 id="finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks"&gt;&lt;a href="https://medium.com/pinterest-engineering/finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks-ea4722e552eb" rel="noopener noreferrer"&gt;Finding zombies in our systems: A real-world story of CPU bottlenecks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In early 2025, Pinterest&amp;rsquo;s Ray ML training jobs kept crashing due to flaky network connections, and it took the Kubernetes platform team over three months to track down the culprit. The first clue was that the EC2 ENA network driver reset itself whenever its transmit queue stalled for more than 5 seconds, a classic symptom of CPU starvation; weirdly, the resets only happened in a single availability zone even though cluster configs looked identical, and rebooting nodes only bought about a week of relief. On 96-vCPU GPU instances, aggregate &lt;code&gt;perf&lt;/code&gt; profiles looked completely normal; only per-core, per-second &lt;code&gt;mpstat&lt;/code&gt; monitoring revealed a single CPU core pinned at 100% system time for several seconds right when each reset occurred. The team set up automated 2-minute &lt;code&gt;perf record&lt;/code&gt; captures and used Netflix&amp;rsquo;s Flamescope to scrub to the exact second of the spike.&lt;/p&gt;
&lt;p&gt;The culprit: right before every reset, &lt;code&gt;kubelet&lt;/code&gt; spiked to ~6.5% total CPU (normally under 1%), spending nearly all of that time inside the kernel&amp;rsquo;s &lt;code&gt;mem_cgroup_nr_lru_pages&lt;/code&gt; function. The kernel was tracking nearly 70,000 memory cgroups even though only 240 were actually active — &amp;ldquo;zombie memcgs&amp;rdquo; — and walking that list pinned a single core long enough to starve the network driver thread sharing it. The root cause traced back to the AWS Deep Learning AMI (Ubuntu 20.04) base image, which shipped with the Amazon ECS agent enabled by default; unable to join an ECS cluster, the agent crashed in a tight loop, leaking a zombie cgroup on every restart. The fix was simple: disable the ECS agent systemd unit and reboot the fleet. As for why the &amp;ldquo;healthy&amp;rdquo; availability zone never broke? Another bug there prevented the ECS agent from ever starting in the first place.&lt;/p&gt;
&lt;h2 id="programming-still-sucks"&gt;&lt;a href="https://www.stvn.sh/writing/programming-still-sucks-fqffhyp" rel="noopener noreferrer"&gt;Programming Still Sucks.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steven Langbroek wrote this essay to answer the familiar question &amp;ldquo;Will AI take programmers&amp;rsquo; jobs?&amp;rdquo;, and his answer is no: the real culprit is greed, merely dressed up in a new coat called &amp;ldquo;automation.&amp;rdquo; Starting from a casual question at a birthday party, he paints software engineering as a burning ship: no map, no crew, sails mounted backward, useless navigation instruments, and a predecessor who abandoned ship after leaving behind half-baked &amp;ldquo;initiatives.&amp;rdquo; Layoffs, he argues, are signed off by people who know the consequences full well but bow to spreadsheets and quarterly targets, telling themselves they&amp;rsquo;ll &amp;ldquo;fix it later&amp;rdquo; — a &amp;ldquo;later&amp;rdquo; that never comes.&lt;/p&gt;
&lt;p&gt;The sharpest pain point is what happens to junior developers. A junior&amp;rsquo;s value isn&amp;rsquo;t the code they write today, but the fact that one day they become the senior who understands every dark corner of the system; eliminate apprenticeships to optimize short-term output, and a few years later there is nobody left to take the helm. The emotional heart of the piece is Sara, an older infrastructure specialist who inherited her knowledge from Ben and keeps the company alive via a mysterious cron job nobody else understands. When Sara retires, the company will desperately need a replacement after having dismantled the very pipeline that could have trained one. The disaster, Langbroek concludes, isn&amp;rsquo;t technological — it&amp;rsquo;s organizations actively sabotaging themselves.&lt;/p&gt;
&lt;h2 id="how-container-filesystem-works-building-a-docker-like-container-from-scratch"&gt;&lt;a href="https://labs.iximiuz.com/tutorials/container-filesystem-from-scratch" rel="noopener noreferrer"&gt;How Container Filesystem Works: Building a Docker-like Container From Scratch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ivan Velichko&amp;rsquo;s tutorial on iximiuz Labs builds a container by hand using nothing but standard Linux tools like &lt;code&gt;unshare&lt;/code&gt;, &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;pivot_root&lt;/code&gt; — not to replace Docker, but to give readers a clear mental model of what happens under the hood of &lt;code&gt;docker run&lt;/code&gt;. The foundation is the mount namespace: it isolates the mount table — the list of mounted filesystems visible to a process — rather than the underlying physical filesystem itself, something you can verify with &lt;code&gt;findmnt&lt;/code&gt; across two namespaces. Velichko emphasizes mount propagation across &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;shared&lt;/code&gt;, and &lt;code&gt;slave&lt;/code&gt; modes: if ignored, mounts created inside a container can leak out to the host, and &lt;code&gt;pivot_root&lt;/code&gt; — the safer alternative to &lt;code&gt;chroot&lt;/code&gt; — requires that the parent mount not be marked &lt;code&gt;shared&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough mirrors what &lt;code&gt;runc&lt;/code&gt; actually does: prepare a rootfs directory from an Alpine image; create mount, pid, cgroup, uts, and net namespaces; mount the &lt;code&gt;/proc&lt;/code&gt;, &lt;code&gt;/dev&lt;/code&gt;, and &lt;code&gt;/sys&lt;/code&gt; pseudo-filesystems with appropriate restrictions; bind-mount container-specific &lt;code&gt;/etc/hosts&lt;/code&gt;, &lt;code&gt;/etc/hostname&lt;/code&gt;, and &lt;code&gt;/etc/resolv.conf&lt;/code&gt; files; swap the root filesystem via &lt;code&gt;pivot_root&lt;/code&gt;; and harden the container by remounting sensitive &lt;code&gt;/proc&lt;/code&gt; paths read-only and masking others with &lt;code&gt;tmpfs&lt;/code&gt; or &lt;code&gt;/dev/null&lt;/code&gt;. On the security side, an untrusted rootfs can contain symlinks pointing outside the container, so production runtimes use &lt;code&gt;openat2()&lt;/code&gt; with &lt;code&gt;RESOLVE_NO_SYMLINKS&lt;/code&gt; and operate via file descriptors to prevent TOCTTOU race conditions. Finally, bind mounts are the exact same mechanism powering Docker&amp;rsquo;s &lt;code&gt;-v&lt;/code&gt; flag when sharing host volumes with a container.&lt;/p&gt;
&lt;h2 id="using-ai-to-write-better-code-more-slowly"&gt;&lt;a href="https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/" rel="noopener noreferrer"&gt;Using AI to write better code more slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amid the &amp;ldquo;vibe coding&amp;rdquo; frenzy, Nolan Lawson asks the opposite question: if so many people are using LLMs to crank out sloppy code as fast as possible, can we use the exact same tools to write better code more slowly? His answer is yes. His workflow centers on multi-model code review: having Claude, Codex, and Cursor Bugbot independently review a pull request, rank issues as critical, high, medium, or low, and then manually synthesizing and verifying their findings to filter out false positives. Using distinct models and wiping context between rounds reduces the chance that all of them hallucinate the same nonexistent bug. He then has the agent fix the critical and high issues, repeats the review loop until none remain, weighs whether the minor issues are worth addressing, and throws out the entire pull request if the process exposes a fundamental architectural flaw.&lt;/p&gt;
&lt;p&gt;Interestingly, his overall delivery speed hasn&amp;rsquo;t increased at all: the review process routinely uncovers pre-existing bugs in surrounding code, turning every new feature into a side quest of writing tests and cleaning up legacy debt. For anyone letting agents open hundred-line pull requests they don&amp;rsquo;t fully grasp, Lawson advises slowing down: ask the agent how the code works and where it could break, have it generate documentation with Mermaid diagrams, or use Matt Pocock&amp;rsquo;s &lt;code&gt;/grill-me&lt;/code&gt; skill until you understand every detail. This approach burns more tokens, but pays off in a deep understanding of failure modes and a much healthier codebase.&lt;/p&gt;
&lt;h2 id="how-cockroachdb-built-vector-indexing-at-scale"&gt;&lt;a href="https://blog.bytebytego.com/p/how-cockroachdb-built-vector-indexing" rel="noopener noreferrer"&gt;How CockroachDB Built Vector Indexing at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo breaks down C-SPANN, the vector indexing algorithm CockroachDB designed in-house because no off-the-shelf approach fit a distributed transactional database. Vectors have no natural total ordering, rendering B-trees useless, so every vector index trades exactness for speed via approximate nearest neighbor (ANN) search. CockroachDB set six hard constraints: no central coordinator node, no reliance on massive in-memory structures, minimal network hops, shardable across nodes, no hot spots, and real-time incremental updates — ruling out both traditional HNSW and IVF. C-SPANN instead uses a wide, shallow hierarchical K-means tree: with a branching factor around 100, a million vectors need just three levels and ten billion vectors need five.&lt;/p&gt;
&lt;p&gt;The key architectural decision is storing each partition as ordinary key-value rows inside CockroachDB, allowing the index to automatically inherit range splitting, load balancing, replication, and multi-region placement without a separate infrastructure stack. To cut storage overhead, RaBitQ compresses 1,536-dimensional vectors from ~3 KB down to 200 bytes (a 94% reduction), then uses the full-precision vectors to rerank a small candidate set. For multi-tenancy, prefix columns like &lt;code&gt;(user_id, embedding)&lt;/code&gt; create isolated per-tenant trees, combining with &lt;code&gt;REGIONAL BY ROW&lt;/code&gt; to satisfy data-residency rules. The trade-offs are stated plainly: C-SPANN trails dedicated vector databases on raw tail latency and currently only supports Euclidean distance in preview, but it is a great fit for workloads where vectors need to live alongside transactional data.&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 #97</title><link>https://miti99.com/en/post/2026/04/17/</link><pubDate>Fri, 17 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/17/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #97.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-we"&gt;&lt;a href="https://blog.cloudflare.com/rethinking-cache-ai-humans/" rel="noopener noreferrer"&gt;Why we&amp;rsquo;re rethinking cache for the AI era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare reports that 32% of traffic across its network is automated, with AI bots alone surpassing 10 billion requests per week. Unlike human visitors, AI crawlers—especially agentic RAG loops that iteratively refine queries—exhibit 70–100% unique URL ratios, constantly fetching fresh deep links across documentation, source code, and media rather than revisiting popular pages, and they maintain no session state so every worker instance looks like a separate client. The result is soaring cache-miss rates, ineffective traditional prefetching, and degraded performance for real humans: Wikimedia saw multimedia bandwidth jump 50%, while Read the Docs, Fedora, and Diaspora all suffered slowdowns from crawlers repeatedly pulling large assets.&lt;/p&gt;
&lt;p&gt;In the short term, Cloudflare is experimenting with replacing classic LRU cache eviction with SIEVE and S3-FIFO—early tests show human cache-hit ratios stay protected even under heavy AI crawler load—while developing ML-driven, workload-aware caching policies. Longer term, they envision dedicated caching tiers for AI traffic: human users stay on fast latency-optimized edge caches, latency-sensitive AI workloads like live RAG or summarization use an intermediate tier, and latency-tolerant model-training crawlers get routed to deeper storage tiers or queued during origin overload.&lt;/p&gt;
&lt;h2 id="a-behind-the-scenes-look-at-how-we-release-the-spotify-app-part-1"&gt;&lt;a href="https://engineering.atspotify.com/2025/04/how-we-release-the-spotify-app-part-1" rel="noopener noreferrer"&gt;A Behind-the-Scenes Look at How We Release the Spotify App (Part 1)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spotify pulls back the curtain on how its Release team ships the iOS and Android apps to more than 675 million users, bundling hundreds of changes into every weekly release. Release Managers both coordinate across feature squads and build the internal release tooling, constantly balancing velocity against stability. Following version 8.9.2 as a case study, each release cycle spans roughly two weeks: week one is active development with nightly builds shipped to internal alpha testers; in week two, a release branch is cut that accepts only critical cherry-pick fixes while moving through beta testing and manual regression QA; the weekend and Monday cover final stabilization and app-store submission, followed by a staged rollout from 1% to 100% of users on Tuesday and Wednesday.&lt;/p&gt;
&lt;p&gt;Before submission, every release must clear strict quality gates: all commits pass automated test suites, zero release-blocking bugs remain open, stakeholder teams sign off, crash-free rates stay above threshold, and content-consumption telemetry looks healthy. To de-risk big launches like Audiobooks in 8.9.2, major features get dedicated rollout schedules and extra crash scrutiny; feature flags let engineers merge unfinished code safely while keeping it dark in production; and the initial 1% rollout catches severe regressions before they hit the wider user base. Thanks to this discipline, roughly 95% of scheduled releases ship to 100% of users on time every week.&lt;/p&gt;
&lt;h2 id="components-of-a-coding-agent"&gt;&lt;a href="https://magazine.sebastianraschka.com/p/components-of-a-coding-agent" rel="noopener noreferrer"&gt;Components of A Coding Agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sebastian Raschka explains that coding agents like Claude Code or Codex CLI are fundamentally software harnesses wrapped around an LLM that turn a raw text model into a capable engineering tool. An agent&amp;rsquo;s real-world effectiveness, he argues, comes not just from the underlying model weights, but largely from the harness—its control loop, runtime environment, and context-management discipline. A well-engineered harness makes both reasoning and non-reasoning models perform dramatically better than they ever could inside a plain chat window.&lt;/p&gt;
&lt;p&gt;The article breaks a coding agent down into six core components. First is &lt;em&gt;live repo context&lt;/em&gt;: gathering directory structure, Git status, and project instructions before acting on a prompt. Second is &lt;em&gt;prompt prefix caching&lt;/em&gt;: splitting the prompt into a stable prefix (tools, system instructions) and a dynamic suffix so KV caches can be reused across turns, slashing latency and cost. Third is &lt;em&gt;structured tool access&lt;/em&gt;: an explicit catalog of typed tools gated by permission checks, far safer and more reliable than parsing free-form shell commands from prose. Fourth is &lt;em&gt;context compaction&lt;/em&gt;: truncating giant tool outputs, deduplicating repeated file reads, and summarizing old turns to prevent context bloat. Fifth is &lt;em&gt;structured session memory&lt;/em&gt;: maintaining both a full on-disk transcript and a compact working memory so long sessions stay sharp and resumable. Sixth is &lt;em&gt;bounded subagents&lt;/em&gt;: letting the primary agent delegate subtasks to scoped worker agents with isolated context windows, enabling parallel execution without losing control.&lt;/p&gt;
&lt;h2 id="say-the-thing-you-want"&gt;&lt;a href="https://terriblesoftware.org/2026/04/01/say-the-thing-you-want/" rel="noopener noreferrer"&gt;Say the Thing You Want&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of &lt;em&gt;Terrible Software&lt;/em&gt; offers a simple piece of career advice that engineers routinely ignore: tell your manager explicitly what you want. At the end of a 1:1, when asked &amp;ldquo;anything else?&amp;rdquo;, countless engineers say &amp;ldquo;nope, all good&amp;rdquo; even when they badly want to lead the next project, get promoted, or switch teams—afraid of sounding entitled, being told they aren&amp;rsquo;t ready, or admitting out loud that they want something they might not get. Yet as the post puts it, a goal you keep in your head has &amp;ldquo;zero surface area&amp;rdquo;—nobody can react to it, build on it, or help you reach it.&lt;/p&gt;
&lt;p&gt;Even the most caring manager cannot read your mind and is juggling a dozen other priorities. When a tech-lead opportunity opens up between two equally capable engineers, the one who previously said &amp;ldquo;I want to lead a project&amp;rdquo; gets the nod almost every time. Saying it out loud also unlocks actionable feedback: your manager can tell you the exact skill gaps between where you are and where you want to go—a roadmap self-assessment can never provide because we all have blind spots. Speaking the goal also makes it real and forces you to act on it. Starting doesn&amp;rsquo;t require a grand speech: just ask what the path to Senior looks like or what it would take to lead an upcoming initiative. And if merely stating a career goal gets held against you, that tells you something vital about your workplace too.&lt;/p&gt;
&lt;h2 id="agentic-coding-and-microservices"&gt;&lt;a href="https://www.natemeyvis.com/agentic-coding-and-microservices/" rel="noopener noreferrer"&gt;Agentic Coding and Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nate Meyvis responds to Ben Borgers&amp;rsquo;s argument that AI coding agents will push the industry toward microservices because LLMs work better inside small, strictly encapsulated contexts. Meyvis agrees with the premise—strict encapsulation helps LLMs—but points out that encapsulation has &lt;em&gt;always&lt;/em&gt; helped humans, teams, and agents alike, and isn&amp;rsquo;t unique to AI. In fact, coding with AI has pushed his own projects &lt;em&gt;more&lt;/em&gt; toward monoliths: microservices still suffer from all the classic distributed-data headaches whenever features span service boundaries, and moving faster with AI means you hit those cross-service walls even sooner; meanwhile, deploying a monolith is faster and simpler, matching the tight iteration loop of AI-assisted development.&lt;/p&gt;
&lt;p&gt;His core point is that network boundaries between microservices are neither necessary nor sufficient for good encapsulation: microservices regularly degenerate into distributed monoliths with hidden coupling, while a single-repo monolith can enforce clean module boundaries with discipline. Left to their own devices, LLMs naturally prefer adding code to an existing service over standing up a new one, and a clear &lt;code&gt;AGENTS.md&lt;/code&gt; file paired with regular refactoring prompts is usually enough to keep subsystem boundaries clean inside a monolith without paying the operational tax of distributed systems. In an AI-first workflow, a well-structured, well-documented monolith is often the most pragmatic choice.&lt;/p&gt;
&lt;h2 id="garbage-collection-from-first-principles-to-modern-collectors-in-java-go-and-python"&gt;&lt;a href="https://shbhmrzd.github.io/systems/garbage-collection/memory-management/2026/04/01/garbage-collectors-deep-dive.html" rel="noopener noreferrer"&gt;Garbage Collection: From First Principles to Modern Collectors in Java, Go and Python&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This comprehensive guide traces garbage collection from its theoretical roots—starting with John McCarthy&amp;rsquo;s 1960 Lisp paper introducing mark-and-sweep—up through modern collectors in Java, Go, and Python. Following Paul Wilson&amp;rsquo;s classic 1992 survey taxonomy, automatic memory management rests on three foundational families: &lt;em&gt;mark-and-sweep&lt;/em&gt; (simple, but fragments the heap), &lt;em&gt;semi-space copying&lt;/em&gt; (copies live objects into a fresh half-heap, enabling fast bump-pointer allocation at the cost of reserving half of memory), and &lt;em&gt;reference counting&lt;/em&gt; (frees memory deterministically as soon as the count hits zero, but struggles with cyclic references). The weak generational hypothesis—&amp;ldquo;most objects die young&amp;rdquo;—underpins modern collectors that focus collection effort on a small young generation to dramatically cut pause times.&lt;/p&gt;
&lt;p&gt;Comparing production runtimes: Go uses a non-moving, concurrent tri-color mark-and-sweep collector with a hybrid write barrier targeting sub-millisecond pauses without heap compaction. Java&amp;rsquo;s G1GC divides the heap into 1–32MB regions and uses Snapshot-At-The-Beginning (SATB) concurrent marking, while ZGC encodes metadata into unused pointer bits (&lt;em&gt;colored pointers&lt;/em&gt;) and uses load barriers to remap pointers lazily, achieving sub-millisecond pauses even on multi-hundred-gigabyte heaps. CPython relies primarily on GIL-protected reference counting backed by a three-generation (0, 1, 2) cycle detector. Looking at the trade-offs: tracing collectors dominate server runtimes because reference counting&amp;rsquo;s per-write overhead compounds quickly; compacting collectors unlock fast bump allocation at the cost of moving objects and rewriting pointers, while non-compacting collectors like Go&amp;rsquo;s avoid pointer updates and accept more complex free-list/span allocation instead.&lt;/p&gt;
&lt;h2 id="i-told-claude-code-to-build-me-an-executive-assistant"&gt;&lt;a href="https://x.com/obie/status/2013955736292704342" rel="noopener noreferrer"&gt;I told Claude Code to build me an executive assistant&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Obie Fernandez, CTO at ZAR, recounts turning Claude Code into a personal executive assistant with a single prompt: asking Claude to design a markdown-based system from scratch to help him operate as a world-class CTO. He didn&amp;rsquo;t create a single folder or template himself—he let Claude design and evolve the structure. Three weeks later, the system had processed 82 meeting transcripts (47 meetings that month alone), tracked 23 team members across 264 lines of rich interpersonal context, and accumulated 11,579 lines of structured organizational knowledge—all while he managed 10 engineers, shipped code, and handled executive duties.&lt;/p&gt;
&lt;p&gt;The secret is that he &amp;ldquo;never thinks about the system&amp;rdquo;: he just talks to Claude naturally, usually dictating via Wispr Flow, with at least one Claude Code terminal session open all day (and multiple parallel sessions when prepping for back-to-back meetings). Everyday prompts include &lt;code&gt;&amp;quot;morning sync&amp;quot;&lt;/code&gt; to synthesize his calendar and top priorities, &lt;code&gt;&amp;quot;prep for 1:1 with Daniel&amp;quot;&lt;/code&gt; to review past notes and surface talking points, and &lt;code&gt;&amp;quot;log decision about X&amp;quot;&lt;/code&gt; to record architectural or org decisions; after every meeting, he simply pastes the raw transcript and lets Claude extract notes and action items. Connecting Calendar, Slack, Twitter, and Linear through Rube/MCP is the linchpin that lets Claude take action directly without context-switching. Fernandez&amp;rsquo;s conclusion: every knowledge worker will eventually run a personal agent harness like this, and those who wait will fall behind.&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_!OXGA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6025205d-78d1-4aa9-b2ba-281d1b9fc57e_2484x3002.png" alt="Monolithic vs Microservices vs Serverless"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!70vn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F71e475fe-34fa-44f8-a564-02f946456588_2508x3042.png" alt="CLI vs MCP"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!INti!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F29e4bde9-65ea-4d95-bc99-1802e4f74448_2484x3002.png" alt="Comparing 5 Major Coding Agents"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ujMG!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1fd50345-af15-4236-ab47-73225d1aa660_800x803.jpeg" alt="JWT Visualized"&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 #37</title><link>https://miti99.com/en/post/2025/07/26/</link><pubDate>Sat, 26 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #37.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="i-think-it"&gt;&lt;a href="https://maych.in/blog/its-time-to-give-nix-a-chance/" rel="noopener noreferrer"&gt;I Think It&amp;rsquo;s Time to Give Nix a Chance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chinmay D. Pai makes the case that Nix deserves a closer look from everyday developers. Unlike traditional package managers that install everything into shared global directories, Nix stores each package inside an immutable &lt;code&gt;/nix/store&lt;/code&gt; path prefixed with a cryptographic hash of all its build inputs. That allows multiple versions of the same software to coexist without conflict, each carrying its own complete dependency tree. Nix flakes pin dependencies so environments can be reproduced reliably across machines, even if they don&amp;rsquo;t guarantee bit-for-bit identical builds in every case. You can also try out tools without installing them permanently via &lt;code&gt;nix shell&lt;/code&gt; or &lt;code&gt;nix run&lt;/code&gt;, while the immutable store and non-standard filesystem layout neutralize several common Linux attack vectors.&lt;/p&gt;
&lt;p&gt;Pai is equally candid about the downsides: learning a bespoke functional language, deciphering cryptic error messages, understanding Nix&amp;rsquo;s evaluation model to debug issues, wrestling with software that hardcodes standard Linux paths, high disk usage, and fragmented documentation. To get started without drowning, he recommends installing via the Determinate Systems Installer, experimenting with &lt;code&gt;nix shell&lt;/code&gt;, and then setting up a simple project dev shell. Nix pays off most for teams plagued by &amp;ldquo;works on my machine&amp;rdquo; drift, painful onboarding, cross-platform builds, or strict compliance requirements—while small projects with stable dependencies probably don&amp;rsquo;t need it yet.&lt;/p&gt;
&lt;h2 id="you-can-choose-tools-that-make-you-happy"&gt;&lt;a href="https://borretti.me/article/you-can-choose-tools-that-make-you-happy" rel="noopener noreferrer"&gt;You Can Choose Tools That Make You Happy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fernando Borretti argues that programmers&amp;rsquo; technology choices are driven largely by emotion rather than the pure engineering rationality we claim. People pick tools that match an aesthetic and a desired self-image: using Emacs because it feels intellectually elite, or running NetBSD because it fits a cyberpunk persona. Afterward, we construct technical rationalizations to disguise the real motive—downplaying glaring flaws in niche tools (&amp;ldquo;sure, I had to write my own HTTP server&amp;rdquo;), inventing dubious advantages, or lobbing vague criticisms at mainstream options like &amp;ldquo;Docker is too complex&amp;rdquo; or &amp;ldquo;C++ builds character, whereas Rust makes you soft.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Borretti has no problem with emotional tool choices as long as you don&amp;rsquo;t lie to yourself or others. If you pick something for its aesthetic or identity, lean into it honestly and intentionally; just don&amp;rsquo;t claim SNOBOL has a bright commercial future, or tell your manager the decision came from a sober cost-benefit analysis. The core message: you are allowed to choose tools that make you happy—just be honest about why. He also cautions that passion still needs a reality check, because extreme choices divorced from reason can sink years into dead-end paths.&lt;/p&gt;
&lt;h2 id="the-copilot-delusion"&gt;&lt;del&gt;&lt;a href="https://deplet.ing/the-copilot-delusion/" rel="noopener noreferrer"&gt;The Copilot Delusion&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post delivers a sharp critique of AI coding assistants like GitHub Copilot and their negative impact on software development. The author argues that these tools generate code without any real understanding of system architecture or deep technical trade-offs.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The core concern is that relying on AI erodes developers&amp;rsquo; critical thinking and ability to learn. When we &amp;ldquo;outsource our thinking to AI,&amp;rdquo; we also &amp;ldquo;outsource our learning&amp;rdquo; to it. These tools lack intuition for hardware performance, memory management, and low-level optimization—key ingredients of high-quality software engineering.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author worries about the cultural shift across the industry, warning it could produce a generation of developers who prioritize fast output over quality, threatening the &amp;ldquo;hacker spirit&amp;rdquo; and deep technical curiosity. The risk is a wave of developers who think they are skilled simply because their bot got CI to pass, while lacking foundational understanding.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Main concerns:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- AI generates code without understanding system architecture&lt;/del&gt;
&lt;del&gt;- Erosion of developers&amp;rsquo; critical thinking skills&lt;/del&gt;
&lt;del&gt;- Lack of intuition around performance and optimization&lt;/del&gt;
&lt;del&gt;- Risk of creating a generation of developers who are only &amp;ldquo;good on paper&amp;rdquo;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="why-cline-doesn"&gt;&lt;a href="https://cline.bot/blog/why-cline-doesnt-index-your-codebase-and-why-thats-a-good-thing" rel="noopener noreferrer"&gt;Why Cline Doesn&amp;rsquo;t Index Your Codebase (And Why That&amp;rsquo;s a Good Thing)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this May 2025 post, the Cline team explains why they deliberately avoid vector-indexing your codebase and why direct exploration fits their agent better. First, code doesn&amp;rsquo;t work in isolated fragments: chopping it into small chunks breaks interconnected logic, like trying to understand a symphony from random ten-second clips, especially since source code lacks the clean paragraph boundaries of prose. Second, indexes go stale fast as code is refactored and updated; an outdated snapshot can lead an AI to suggest functions that no longer exist or miss recent architectural shifts. Third, generating vector embeddings creates a secondary copy of your intellectual property, bringing extra storage and security risk.&lt;/p&gt;
&lt;p&gt;Instead, Cline navigates a repository the way an experienced engineer does: systematically following imports and call chains. When modifying a payment handler, for instance, Cline traces imports to locate custom error utilities, inspects sibling functions to pick up local conventions, and checks call sites—building contextual understanding rather than doing fuzzy pattern matching. That workflow is now practical thanks to the huge context windows of modern frontier models, shifting the bottleneck from raw retrieval volume to context quality: prioritizing comprehension over retrieval.&lt;/p&gt;
&lt;h2 id="the-perfect-commit"&gt;&lt;a href="https://simonwillison.net/2022/Oct/29/the-perfect-commit/" rel="noopener noreferrer"&gt;The Perfect Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he organizes his work around the idea of the &amp;ldquo;perfect commit,&amp;rdquo; treating each commit as a carefully packaged unit of work rather than a rough save point. A perfect commit bundles four things: an implementation focused on a single change, tests proving it works, updated documentation, and a link to an issue thread with the surrounding context. In his view, tests boost long-term velocity by letting you change code confidently without regressions, so every project should start with at least one passing test. Documentation—whether for a Python module, a web service, or a CLI tool—belongs right inside the repository so it stays in sync with the code, is versioned alongside it, and gets reviewed in the same diff.&lt;/p&gt;
&lt;p&gt;Rather than writing long commit messages, Willison puts rich context into GitHub issues, which are easier to search, support pasted screenshots, and can be updated later. He acknowledges this goes against traditional Git orthodoxy, but finds it much more effective in practice. Not every commit needs all four elements: tiny bug fixes or doc typo corrections can skip the ceremony. For messy exploratory work, use a separate branch with rough commits and squash-merge a single clean commit into &lt;code&gt;main&lt;/code&gt;. To make the habit effortless, he uses cookiecutter templates that pre-configure test harnesses and GitHub Actions from day one, as seen across open-source projects like Datasette and &lt;code&gt;sqlite-utils&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-software-engineering-kanagawa-moment"&gt;&lt;a href="https://pashabitz.substack.com/p/the-software-engineering-kawagara" rel="noopener noreferrer"&gt;The Software Engineering Kanagawa Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pasha uses Hokusai&amp;rsquo;s woodblock print &amp;ldquo;The Great Wave off Kanagawa&amp;rdquo; as a metaphor for the wave of AI automation reshaping software engineering. In his view, programming is uniquely exposed to automation because abundant training data exists, outputs can be verified objectively, and the field faces none of the regulatory barriers that protect professions like medicine or law. Coding agents have already moved well past autocomplete, turning ticket descriptions into complete pull requests, while junior developer hiring has noticeably cooled. Well-bounded, self-contained tasks like refactoring and test writing are being automated first.&lt;/p&gt;
&lt;p&gt;What remains for humans is understanding business needs, shaping product design, setting up technical scaffolding, and defining coding conventions—though the author admits even that boundary is fragile as language models keep improving. His advice for engineers at every level is to adopt coding agents actively, audit workflows for automation opportunities, and sharpen product and business judgment; junior developers in particular should practice shipping end-to-end products, learn deployment infrastructure, and study how real production systems are built rather than just following tutorials. His conclusion is blunt: the wave cannot be stopped, and much like agricultural mechanization shifted labor out of farming, it could displace millions of coding jobs.&lt;/p&gt;
&lt;h2 id="websockets-guarantee-order---so-why-are-my-messages-scrambled"&gt;&lt;a href="https://www.sitongpeng.com/writing/websockets-guarantee-order-so-why-are-my-messages-scrambled" rel="noopener noreferrer"&gt;WebSockets guarantee order - so why are my messages scrambled?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sitong Peng recounts an interesting debugging mystery: WebSocket messages were showing up out of order in her logs, even though WebSockets run over TCP, which guarantees in-order delivery. The culprit wasn&amp;rsquo;t the network protocol, but the application layer. The message event handler called &lt;code&gt;await blob.arrayBuffer()&lt;/code&gt;, suspending execution while each message payload was processed; because processing took anywhere from 1 to 5 seconds per message, a smaller message that arrived later could finish before an earlier, slower one. TCP delivered the frames in exact order—the async handler scrambled them afterward.&lt;/p&gt;
&lt;p&gt;Peng walks through two fixes. The first buffers incoming messages in a queue and processes them in batches of five with &lt;code&gt;Promise.all&lt;/code&gt;, preserving order across results while still allowing parallelism within each batch. The second uses an async generator to process messages strictly one at a time—slower since there is no concurrency, but guaranteeing total ordering when application logic requires it. The broader lesson is how tricky it is to debug across multiple abstraction layers: even when the transport layer guarantees reliability and ordering, careless concurrency in application code can undo it, so you have to separate what each layer actually promises.&lt;/p&gt;
&lt;h2 id="why-agents-are-bad-pair-programmers"&gt;&lt;a href="https://justin.searls.co/posts/why-agents-are-bad-pair-programmers/" rel="noopener noreferrer"&gt;Why agents are bad pair programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Searls argues that AI coding agents make terrible pair programmers because they &amp;ldquo;write code faster than humans can think.&amp;rdquo; That speed breaks the collaborative loop: the human partner can&amp;rsquo;t keep up, tunes out, and loses track of how the system works. It feels like pairing with someone who grabs the keyboard and types in silence at superhuman speed. When the agent inevitably hits a wall, the human lacks the mental context from earlier decisions needed to bail it out; worse, the agent may have solved the wrong problem entirely, leaving behind a pile of accidental complexity to clean up.&lt;/p&gt;
&lt;p&gt;Searls suggests two paths forward. First, move agents into an asynchronous workflow: hand them self-contained tasks and review the output via pull requests, like GitHub&amp;rsquo;s Coding Agent. Second, slow things down when working synchronously by using &amp;ldquo;Edit&amp;rdquo; or &amp;ldquo;Ask&amp;rdquo; modes instead of fully autonomous &amp;ldquo;Agent&amp;rdquo; mode; ping-pong pairing in Edit mode, where you review and approve each step, strikes the best balance. He also urges toolmakers to add adjustable generation speed, pause-and-ask checkpoints, UIs that reflect workflow state like GitHub integration and to-do lists, less overconfident agent personas that check in more often, and voice chat. Those changes would turn agents into genuine collaborators rather than lone sprinters.&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>