Newsletter #116
Enjoy Newsletter #116.
8 myths on software engineering and AI
Brian Houck introduces the paper “8 Myths on Software Engineering and GenAI,” 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’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.
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’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.
You Don’t Love systemd Timers Enough
The author argues that while we still call every scheduled task a “cron job,” in 2026 there is rarely a reason to use actual cron. A systemd timer is a unit that schedules another unit—typically a matching .service—cleanly separating “when to run” from “what to run.” That separation solves classic cron headaches: unpredictable $PATH environments, swallowed stdout/stderr, hard-to-audit run history, and cryptic schedule syntax. Output goes straight into the journal, while systemctl status and systemctl list-timers show both the last run and the next scheduled trigger. The post also notes that ExecStart= 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 ExecCondition=, OnFailure=, and Restart= instead of reinventing them by hand.
The most valuable part highlights capabilities that go well beyond traditional cron. The systemd-analyze calendar command lets you validate and test schedule expressions before deploying them. Alongside wall-clock schedules via OnCalendar=, timers support monotonic schedules like OnBootSec= and OnUnitActiveSec=—running relative to system boot or the unit’s last activation, which often matches operational intent much better than fixed minute or hour intervals. Options like WakeSystem=, Persistent=, RandomizedDelaySec=, FixedRandomDelay=, and RandomizedOffsetSec= 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 cron.
Life is too short for a slow terminal
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’t there: no oh-my-zsh, no plugin manager, just sourcing the three plugins he actually needs directly. Because compinit is a common startup bottleneck, he caches .zcompdump so a full check runs only about once a day, while every other shell launch uses compinit -C.
For heavy tools like nvm or kubectl 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 eval "$(tool init zsh)" into .zshrc is a prime candidate for lazy-loading. Prompts should also avoid running synchronous git status checks inside large repositories; an async prompt like pure 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 time zsh -i -c exit, hyperfine, zprof, 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.
OpenCodeReview
OpenCodeReview is Alibaba’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 ocr scan command can audit entire files or directories when exploring an unfamiliar codebase.
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.
Golang code review notes II
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: os.Root 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 math/rand remains unsuitable for cryptographic use.
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 uint32(len(s))—which can corrupt framing boundaries in serialization libraries. httputil.ReverseProxy.Director is vulnerable to hop-by-hop header abuse, so code should migrate to Rewrite, which runs after those headers are stripped. Shallow pointer copies in net/url can lead to shared-state mutation and race conditions; null bytes crossing CGO or C library boundaries can bypass validation checks; and encoding/json can silently skip a custom marshaller if the method uses a pointer receiver while the struct is passed by value. JSON APIs also aren’t automatically immune to CSRF unless Content-Type, SameSite cookies, and request origins are properly validated. The authors also release a set of Semgrep rules to catch several of these patterns automatically.
Thoughts on starting new projects with LLM agents
Eli Bendersky shares his experience using LLM agents to build watgo, 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’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.
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.
The History of Pets vs Cattle and How to Use the Analogy Properly
Randy Bias recounts the origin and intended meaning of the “pets vs. cattle” 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 “pet” with the fungibility of “cattle.” A “pet” 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. “Cattle” 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.
Bias also warns that misusing the analogy strips away its original lesson. A prime example was Kubernetes originally naming StatefulSets “Pet Sets”: the stateful distributed systems cited as examples—Cassandra, Kafka, MongoDB—are actually architected as “cattle,” since they handle node failure through horizontal scale-out. Defining a “pet” as any system that needs special handling, rather than a system that isn’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.
Every byte matters
Farid Zakaria reminds us that performance isn’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 is_alive, 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’s benchmark, this yielded up to a 30x speedup when the struct size reached 1KiB.
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.
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.
Comments