Newsletter #123
Enjoy Newsletter #123.
Our Collective Bike Shed Moment
This post borrows Parkinson’s “Law of Triviality”: a fictional committee approves a nuclear reactor design in ten minutes because the topic is too complex for anyone to debate, then spends forty-five minutes arguing over what color to paint the bike shed. The author argues that society is re-enacting that exact meeting in the face of AI. LLMs have blown past one supposed ceiling after another—from “they can’t write real code” to hallucinations—while growing steadily stronger at formal methods and multi-step reasoning, yet critics keep moving the goalposts while the broader public carries on as if nothing fundamental has changed.
Demirbas attributes this collective shrug to normalcy bias—our default assumption that tomorrow will look mostly like yesterday—and Douglas Adams’s “Somebody Else’s Problem” field, where something colossal is ignored precisely because it is too big to process. Learning new AI tools to stay employable over the next few years is a sensible personal strategy, but it doesn’t answer what happens over the coming decades. What worries the author is that even the people who should be leading the serious conversation—technologists, researchers, economists, policymakers, ethicists, defense planners, and educators—still aren’t grappling with the long-term societal transformation at the depth required, while public attention remains fixated on surface-level bike-shedding.
p99 0 ms* autocomplete for 240 million domain names
Ruurtjan Pul explains how Wirewiki achieves instantaneous-feeling autocomplete across a dataset of 240 million domain names. The trick starts in the browser: on keydown, the client prefetches autocomplete results not only for the current prefix, but for every valid character the user might type next; by the time the next keyup fires, the suggestions are already sitting in browser memory ready to render. Because domain names use a tiny character set (38 characters), a single response bundling top suggestions for all possible next keystrokes contains at most 312 domain names—roughly 2.5 kB compressed. According to the author’s measurements, 99% of keystrokes have at least a 121 ms budget before release, so “p99 0 ms” means the result is already local before keyup, not that network packets travel faster than light.
On the server side, the dataset is split into two tiers. An in-memory prefix tree (trie) holds the top eight suggestions for every prefix drawn from the Tranco top one million domains. The remaining 240 million domains from ICANN’s CZDS are sorted, front-coded (prefix-compressed), and packed into fixed-size blocks on SSD; a 27 MB in-memory index locates the right block in one hop while the OS page cache keeps hot blocks in RAM. The Go API typically responds in ~2 ms, and under 1,600 requests/sec Nginx plus the API still maintain a ~15 ms p99. Once the origin server is that fast, network round-trip time through Cloudflare dominates perceived latency—hence the asterisk in the title: a single European server still can’t beat the 121 ms budget for users halfway across the globe. The takeaway is to measure latency from the user’s physical interaction rather than just server processing time.
Building Reliable Agentic AI Systems
This article on Martin Fowler’s site chronicles how Bayer built PRINCE, an agentic AI platform that helps pharmaceutical researchers query decades of preclinical toxicology data locked inside thousands of PDF study reports. The architecture evolved through three stages: structured metadata search, basic RAG question-answering, and finally a multi-agent workflow for complex cross-study questions. Orchestrated with LangGraph, the system steps through intent clarification, planning, research execution, evidence sufficiency checks, and report synthesis. Specialized research agents combine OpenSearch-backed RAG over unstructured PDF narratives with Athena Text-to-SQL for filtering, aggregating, and comparing structured study tables, while dedicated reflection nodes audit progress, data completeness, and draft quality.
Reliability comes from the engineering harness around the models rather than clever prompting or waiting for a smarter foundation model. Each graph node receives only the narrow slice of context it needs; workflow state is checkpointed after every node so failures resume from the last completed step instead of restarting from scratch; and bounded retries operate at both the individual model-call level and the graph-node level, failing over to backup models or cloud regions when needed. In a heavily regulated pharmaceutical environment, user trust also depends on surfacing intermediate reasoning steps, linking every claim directly to source PDF pages and paragraphs, running continuous evaluations against both golden datasets and production traffic, and keeping domain scientists in the loop. Breaking a monolith prompt into an observable, checkpointed graph made the system dramatically easier to test, recover, and improve.
Growing as an engineer in a world of AI
Norberto Lopes argues that the biggest risk AI poses to early-career engineers isn’t replacing their jobs—it’s short-circuiting their growth by removing the very friction that produces deep learning. Reading documentation, experimenting, failing, debugging, and piecing together your own mental model builds durable knowledge through “desirable difficulty” and the generation effect. Getting an instant answer is not the same as understanding the problem: if an engineer simply accepts generated code and moves on to the next ticket, they can ship working features while remaining unable to explain the design choices, trade-offs, or failure modes. That “cognitive debt” stays hidden until production breaks in a way the AI can’t immediately fix.
Lopes doesn’t advocate shunning AI; instead, he recommends using it deliberately as a learning amplifier: ask why an approach works, ask for alternative designs and failure scenarios, read the code and sketch your own mental model before asking the LLM to explain it, type out critical sections yourself instead of copy-pasting, and treat code review and technical writing as active thinking exercises. Foundational depth still comes from books, Unix fundamentals, primary specifications, architecture debates, and postmortems—and the time saved by AI should be reinvested into harder engineering thinking. Developing junior engineers is also an organizational responsibility: managers must protect space for learning, evaluate judgment and system understanding rather than raw ticket velocity, and keep hiring and mentoring the next generation.
Note To My Younger Self
Reflecting on two decades at major tech companies, Yew Jin Lim distills eight career principles that sound simple on paper but take discipline to practice. Fall in love with the actual craft rather than chasing titles, and treat your first job as a laboratory for learning how to solve problems; keep asking “why” until you reach root causes; build genuine relationships by helping people without keeping score while maintaining healthy boundaries; bring energy and joy to the team around you; listen carefully, tailor explanations to your audience, and know when to stay quiet; write down your impact every single week and proactively ask for specific feedback—then act on it visibly—so you have a concrete record of growth and course-correct early; and whenever you have a choice, optimize for a manager who will invest in your growth over a flashier title, because a great manager shapes how you think for the rest of your career.
Lim candidly acknowledges survivorship bias and notes that none of these rules are absolute. When good work, a supportive manager, kindness, visibility, and mental health come into conflict, the right trade-off depends on your career stage, the skills you still need to build, personal circumstances, and how long a situation will last. When torn between options, a clarifying question is: what will still matter five years from now? Individual projects are almost always forgotten, whereas skills, mental models, and strong relationships keep compounding for decades.
Google hits 50% IPv6
In April 2026, Google’s public telemetry crossed the milestone of 50% of users connecting over IPv6, underscoring that IPv6 is now a mature pillar of the global Internet. At the same time, APNIC Labs measured global IPv6 adoption around 42%, and Geoff Huston explains why that gap isn’t a contradiction. APNIC’s measurement samples run via online ad placements whose impression volume varies across countries, and those per-economy numbers are then weighted by UN/ITU estimates of each country’s total Internet population—meaning the global aggregate depends heavily on sample distribution and weighting methodology. At the individual country level, APNIC’s figures track closely with Google’s and other measurement sources, making the 42%–50% range a solid band for global deployment.
IPv6 adoption remains wildly uneven across regions, fixed-line ISPs, and mobile carriers. Slow migration doesn’t necessarily mean failure: many established ISPs are still amortizing heavy capital investments in IPv4 and CGNAT gear, whereas rapidly growing mobile networks often adopt IPv6 from day one to lower total cost of ownership—making transition a question of capital cycles and market economics rather than pure protocol superiority. Today’s Internet operates as a permanent dual-stack/translation hybrid across direct IPv4, NAT/CGNAT IPv4, and native IPv6, so clinging to IPv4 doesn’t avoid complexity either. Increasingly, interoperability is absorbed at the edge by CDNs, cloud load balancers, and dual-stack transit providers rather than requiring every backend system on earth to cut over simultaneously.
The unwritten laws of software engineering
This post collects seven operational laws that engineers usually only internalize the hard way after living through production outages. First: if production breaks right after a deploy, roll back immediately (if safe to do so) to restore service and investigate afterward, instead of burning precious minutes trying to prove your commit couldn’t possibly be the cause. Second: backups don’t exist until you regularly test restoring from them, and the team knows the exact RPO, RTO, and who has permissions to run the restore. Third: logs must carry enough context and a cross-service correlation ID to trace a request end to end without drowning operators in noise.
Fourth: every database migration must have a fast, concrete, pre-tested rollback plan before it touches production. Fifth: every external dependency will eventually be slow, rate-limit you, or go down completely, so understand its rate limits, failure impact, and SLAs up front and build fallbacks like caching, queues, or serving stale data. Sixth: use the four-eyes principle for risky manual operations in production—if you feel hesitant to wake a teammate up at 2 a.m. to double-check a command, that is the clearest sign you shouldn’t be running it alone. Finally, nothing is more permanent than a temporary hack, so even an MVP must be simple and solid enough to live with for years rather than a fragile patch you promise to clean up later.
Bonus
Images:

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