Newsletter #86
Enjoy Newsletter #86.
Do Not Surrender to the Tech Tree
Tao Burga defends “strong technological determinism”: technology unfolds according to the internal logic of a “tech tree,” driven more by prerequisites, market incentives, and efficiency than by lone genius. The evidence is that independent, near-simultaneous invention is pervasive (Hall–Héroult aluminum smelting, the jet engine, calculus), and isolated societies still converge on the wheel, intensive agriculture, metallurgy, and writing. Yet the author rejects “Technocalvinism”—the fatalistic belief that humans are powerless before this progression. In the short run, deliberate choices, especially altering the order in which technologies arrive, can have lasting consequences: non-proliferation efforts kept the number of nuclear-armed states at nine, Permissive Action Links prevented unauthorized detonations, and COVID-19 vaccines arrived in 10 months instead of 10–15 years.
Turning to AI, the author stresses that it is a dual-use technology: useful for both cyber defense and cyber offense, for discovering vaccines and for engineering dangerous pathogens. Rather than accepting the default branch of the tree, we need differential technological development that builds risk-mitigating technologies in parallel—like inventing seatbelts alongside the automobile. The essay highlights “The Launch Sequence,” a portfolio of 16 concrete projects including Operation Patchlight and The Great Refactor (using AI to harden critical software infrastructure before AI-powered attacks hit), hardware-based verification, and defenses against “sleeper agents” embedded in models. In the author’s view, AI is right inside such a window of agency now, and that window is closing fast.
How to Make Architecture Decisions: RFCs, ADRs, and Getting Everyone Aligned
Lukas Niessen shares an architecture decision-making process designed to avoid two familiar failure modes: decisions rushed through in a hallway chat, or polished documents nobody reads—both of which lead to months of rework. The process has four steps: write an RFC (1–2 days), gather asynchronous feedback (2–3 days), hold a decision meeting (30–60 minutes), and write the ADR the same day. The RFC lays out context, options (including “do nothing”), stakeholders, and open questions; the crucial trick is explicitly ranking priorities rather than just listing pros and cons, because once priorities are clear, the right choice is usually obvious. The async review phase gives everyone time to think and research, and gives quieter teammates a voice.
The decision meeting is not a presentation: everyone has already read the RFC, the group is kept to 5–8 people, and the time is spent resolving open questions, debating, and committing—whether by consensus, consent (no paramount objections), or a single accountable decision-maker. An ADR is the short, permanent record of what was decided and why; the RFC explores options, while the ADR captures the outcome. The author advises including an incremental rollout plan in the RFC, using LLMs as thinking partners rather than ghostwriters, and avoiding common traps: analysis paralysis, too many cooks, skipping the ADR, and ignoring quiet voices.
The cost of a function call
Daniel Lemire measures the overhead of a function call and the payoff of inlining, an optimization where the compiler copies a function’s body directly into the call site. Function calls are cheap but not free: they may require saving and restoring registers on the stack, jumping into and back out of the function, plus prologue and epilogue instructions. On an M4 MacBook with LLVM, a loop summing an integer array through a non-inlined add function takes 0.7 ns per element, versus just 0.03 ns when inlined—over 20 times faster. The reason: once the call is inlined, the compiler vectorizes the loop with SIMD instructions, processing 16 integers in 8 instructions, or half an instruction per number instead of six. Even with SIMD disabled, the inlined version is still roughly 10 times faster.
For a more complex function like counting spaces in a string, the outcome depends on input size. On a 1,000-character string, call overhead is negligible and the inlined version is even slightly slower (115 ns vs. 111 ns); on short strings of 0–6 characters, inlining is noticeably faster (1.0 ns vs. 1.6 ns). The takeaway: tiny, simple functions should be inlined when performance matters, whereas for functions with variable runtime, the inlining decision should be guided by realistic input sizes.
The PERFECT Code Review: How to Reduce Cognitive Load While Improving Quality
Daniil Bastrich introduces PERFECT, a framework of principles to make code reviews less cognitively taxing. Without structure, reviews easily devolve into vague, subjective commentary—causing delays, bike-shedding over trivia, or rubber-stamp approvals. PERFECT orders seven principles by priority: Purpose (the code solves the right problem—a prerequisite), Edge Cases (handling boundary conditions, including “impossible” ones), Reliability (no performance or security regressions), Form (sound design principles, centered on high cohesion and low coupling), Evidence (tests and CI pass), Clarity (the code clearly expresses intent), and Taste (personal preferences are noted as non-blocking).
The author stresses that code review isn’t an all-or-nothing checklist, but a spectrum of techniques that can be applied independently; even a lightweight, structured review delivers high value for little effort. To make it stick, teams should maintain a living written review guide (turning recurring review comments into documented conventions), require self-review before requesting peers, build review into the workflow with clear ownership and SLAs, automate everything possible, stop rubber-stamping with “LGTM,” and practice reviewing regularly. Good review comments state the issue, explain the reasoning, and suggest a concrete alternative.
Semantic Search Without Embeddings
Doug Turnbull argues that semantic search is not synonymous with vector search. Semantic search requires three ingredients: a shared representation for queries and documents, a similarity function, and a matching criterion to decide whether a result actually belongs in the user’s intended scope. Embeddings handle the first two well but struggle with the third: there is no universal similarity threshold across queries, so searching for “fruit that grows on trees” can still return a baseball. Instead, the author proposes using a controlled vocabulary or taxonomy—a hierarchy of domain concepts, like the category tree in the Wayfair WANDS dataset. A taxonomy provides all three: the category tree is the representation, exact category matches rank above parent and sibling categories, and anything beyond a chosen tree distance can be filtered out.
Best of all, no vector index is required: you simply use hierarchical path tokenization (emitting the full ancestor path for every category) inside a standard BM25 index. Because BM25 rewards rarer terms, broad root categories appear frequently and score low, while specific leaf categories are rare and score high—naturally ranking exact matches above parents and grandparents. Taxonomies should start simple and split incrementally as categories grow, and LLMs make classifying both products and queries easier and cheaper than ever. In the author’s view, embeddings may be most useful for building classifiers rather than for direct retrieval and ranking.
My AI Adoption Journey
Mitchell Hashimoto—creator of Vagrant, Terraform, and Ghostty—shares his pragmatic journey toward finding real value in AI tools. Adopting any tool, he notes, goes through three phases: inefficiency, adequacy, and finally workflow-changing discovery. His early steps included: dropping chat interfaces in favor of agents that can read files, run programs, and make HTTP requests; forcing himself to reproduce every manual commit with an agent to learn principles like breaking work into small tasks, separating planning sessions from execution sessions, and giving agents a way to verify their own work; spending the last 30 minutes of each day kicking off agents for deep research, fuzzy ideation, and issue/PR triage; and delegating slam-dunk tasks to agents while focusing on deep work himself with notifications turned off to avoid context switching.
Step five is “harness engineering”: whenever the agent makes a mistake, add instructions to AGENTS.md or build custom tooling so it never repeats that error. The final step is keeping one agent running in the background as much as possible, paired with slower, more thorough models. Right now he runs just a single agent at a time—striking a balance between the deep manual craft he loves and babysitting a machine—and reaches that background-agent goal for about 10–20% of his workday. He emphasizes never running an agent just for the sake of it, only when there is genuinely useful work, and notes that whatever you delegate to an agent is a skill you stop practicing yourself.
Software Engineering is back
Alain Di Chiappari argues that “automatic programming”—Antirez’s term in place of the shallow label “vibe coding”—is bringing real software engineering back. Building products ranging from network configuration to pricing engines with frontier models and coding agents every day, the author noticed a decisive shift starting in December 2025. Thinking through architecture, trade-offs, and edge cases still belongs to humans; what vanished is the manual labor of typing out every line of code. He gets to be the architect without laying every brick by hand, while still drawing on twenty years of bricklaying experience to understand and fix things when needed.
In his view, frameworks historically solved three problems. “Simplification” was often intellectual surrender: buying someone else’s thinking instead of sharpening your own mental models, like wrapping a broken leg in silk. Automating boilerplate was the only legitimate reason, and agents now make custom code cheaper than ever—he builds small purpose-built tools tailored to the problem, where a simple Makefile covers most needs. The third, rarely spoken reason is labor commoditization: companies hire interchangeable “React Developers” instead of software engineers. Meanwhile, agents excel at battle-tested tools like Bash (born in 1989), which is becoming a universal adapter. The essay is a call to stop letting Google, Meta, or Vercel be your architect and start building things you truly own.
Art of Roads in Games
Fascinated by road systems ever since playing SimCity 2000, the author examines why roads in city-building games, despite steady progress, still look subtly wrong: highway ramps kink or wobble unnaturally, high-speed lanes bend too sharply, and intersection corner radii look off. The root cause is the Bézier curve, game developers’ go-to tool: elegant and flexible, yet unable to preserve its shape and curvature under parallel offsetting. In the real world, two wheels on the same axle stay a fixed distance apart, tracing parallel paths; a curve parallel to a Bézier curve is no longer a Bézier curve, so on tight turns the road mesh distorts or self-intersects.
The solution is circular arcs: offset an arc in parallel (as long as the radius stays valid) and you get another circular arc concentric with the original, and chaining arcs of different radii can form complex shapes that follow real civil-engineering principles. Circular arcs also allow O(1) closed-form intersection math instead of the expensive iterative solvers Bézier curves require. Their limitation is constant curvature, which causes lateral acceleration to jump abruptly when entering a turn at high speed; highway engineers use transition curves like clothoids whose curvature ramps up linearly, though the math is much heavier. For lower-speed urban roads, circular arcs are more than good enough. The author built his own road system out of curiosity and because resources for indie developers were so scarce, and hopes to share a better foundation with the community.
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