Enjoy Newsletter #105.

Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals

Abhinav Upadhyay (of the blog Confessions of a Code Addict) wrote a massive ~25,000-word deep dive explaining virtual memory on x86-64 Linux from first principles down to kernel implementation details. Framed as a dialogue between a process named “Alloca” and the “Kernel,” each question from Alloca unlocks a new concept, guiding the reader naturally from “why do we need virtual memory?” (process isolation, memory protection, the illusion of abundant memory) to the underlying mechanisms. Each process gets a 128 TiB user-space half of the 48-bit virtual address space, divided into text, data, BSS, heap, memory-mapped, and stack segments.

The centerpiece is the address translation journey: the CR3 register points to a four-level page table (PGD, PUD, PMD, PTE), where each level consumes 9 bits of the address and the final 12 bits index into a 4 KB page. Because walking four levels on every memory access would be prohibitively slow, the TLB (Translation Lookaside Buffer) caches translations, making TLB hit rate a direct driver of application performance. The article then covers demand paging (allocating physical frames only on first access, distinguishing minor faults that require no I/O from major faults that must read from disk), copy-on-write after fork() (parent and child share read-only frames and only copy on write), mmap() mapping files through the page cache to skip read()’s extra copy, and how the MMU enforces permissions via page table bits, including the NX bit used for W^X protection.

Orchestrating AI Code Review at scale

Cloudflare shares how they brought AI code review into CI across their entire engineering organization, using OpenCode to orchestrate multiple specialized agents rather than asking a single giant model to inspect everything. Each merge request can be evaluated by up to seven domain-specific agents covering security, performance, code quality, documentation, release management, and compliance; an orchestrator agent aggregates the findings, deduplicates them, and makes the final call. Each agent’s prompt is narrowly scoped and explicitly lists “what NOT to flag” to keep noise down. A plugin architecture behind a ReviewPlugin interface decouples version control systems, AI providers, and internal standards, avoiding vendor lock-in.

To balance cost and quality, the system tiers its models: frontier models (Claude Opus 4.7, GPT-5.4) handle orchestration only, standard models (Claude Sonnet 4.6, GPT-5.3) do the bulk of the reviewing, and lightweight models handle text-heavy tasks like documentation. Merge requests are triaged by risk into trivial, lite, or full, so minor edits don’t spin up all seven agents while security-sensitive files always receive a full review. Circuit breakers, timeouts, and a control plane running on Cloudflare Workers keep the system resilient. In its first 30 days, the system ran 131,246 reviews at an average cost of $1.19 per review and an 85.7% cache hit rate.

The 8 Levels of Agentic Engineering

Bassim Eledath proposes an eight-level framework describing how development teams progressively get more leverage out of AI in software engineering, starting from the observation that “AI’s coding ability is outpacing our ability to harness it.” Levels 1 and 2 are autocomplete and AI-first IDEs like Cursor; Level 3 is context engineering, optimizing every token fed into the model; Level 4 is compounding engineering, with a loop of planning, delegating, evaluating, and recording lessons so each session improves on the last; Level 5 uses MCP and skills to connect databases, APIs, and CI; Level 6 is harness engineering, building environments with automated feedback loops so agents can self-correct; Level 7 is asynchronous background agents; and Level 8 is autonomous agent teams coordinating directly without a central orchestrator — an early, still-challenging frontier.

The author highlights several cross-cutting lessons. A “multiplayer” effect means an individual’s productivity depends heavily on their teammates’ level: a Level 7 engineer is still bottlenecked if colleagues manually review PRs at Level 2. Giving agents constraints works better than giving step-by-step instructions, because agents tend to follow instructions rigidly while missing unstated requirements. Finally, using different models for different roles yields better overall results, and the implementing model should never review its own output to avoid self-preference bias.

Hexagonal Architecture is Not a Layered Architecture: Topology, Safety, and When to Walk Away

This article points out that the core difference between hexagonal architecture and layered architecture lies in the direction of dependencies rather than complexity. Layered architecture lets dependencies flow vertically down a chain of controller, service, and repository; in hexagonal architecture, dependencies point inward toward the center: adapters depend on ports, ports belong to the domain, and business logic has no idea what implements an outbound port. Alistair Cockburn’s original 2005 model split ports into driving and driven sides while allowing multiple ports by communication purpose; many modern implementations influenced by Clean Architecture add concentric inner rings, and each ring adds data-mapping overhead that wasn’t part of the original design.

Port ownership matters too: in the author’s chosen layout, Inbound Ports belong to the application layer while Outbound Ports belong to the domain layer, and keeping that distinction clear helps tell whether a change reflects a shift in business requirements or merely a swapped implementation. Adapters handle protocol translation and structural validation like JSON syntax or field types, whereas the domain handles semantic validation like business invariants; if a rule still holds after swapping out the underlying technology, it belongs in the domain. The author is also candid that hexagonal architecture does not automatically give you deployment isolation, input sanitization, or security hardening, and for a CRUD system with 3 controllers, 5 services, and 2 tables, its indirection is a concrete tax paid for abstract benefits; the payoff only grows as complexity grows.

Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding

Vitalii Honchar introduces spec-driven development as the next step beyond “vibe coding”: instead of steering AI through an endless series of small conversational nudges, the developer writes a detailed technical specification up front and lets the AI implement from it autonomously. The workflow follows four sequential stages: co-author a requirements specification in Markdown with the AI, have the AI generate an implementation plan from the spec, break the plan into small manageable tasks, and let the AI execute the whole thing with minimal intervention. The author uses GitHub Spec Kit to bootstrap projects around this workflow.

Compared to vibe coding, this approach keeps the AI aligned with defined requirements, produces documentation from day one, and frees the developer to focus on other work while the AI builds. As a practical example, the author built AgentD — a local service for scheduling and running AI agents — in about five hours without writing code by hand, a project that would have taken weeks manually. In his view, software engineers should shift their focus toward architectural thinking, requirements definition, and quality verification rather than competing with AI on raw coding speed.

Go vs Java: The Minimalist vs The Enterprise Veteran

This article compares two languages built on opposite philosophies: Go embraces radical minimalism (no classes, no inheritance, and no generics until 2022), while Java offers a rich toolkit of generics, inheritance, interfaces, and annotations. According to the author, Go’s minimalism lets new team members read and understand a codebase from day one. On performance, Go compiles to native binaries that start in milliseconds, making it a natural fit for containerized workloads; Java runs on the JVM, starting slower but warming up to high peak throughput thanks to JIT compilation in long-running services.

The concurrency gap has narrowed considerably: Go’s goroutines and channels have long been lightweight and ergonomic, but Virtual Threads in Java 21 now bring M:N scheduling to Java’s familiar thread API, even if the underlying mechanics and trade-offs still differ from goroutines. In terms of ecosystem, Java boasts millions of mature libraries with Spring dominating enterprise development, while Go favors quality over quantity with a standard library sufficient for most tasks. Go shines for infrastructure, CLIs, microservices, and cloud-native apps; Java excels in complex enterprise systems. The author concludes that neither language is universally superior — the right choice depends on project requirements and team expertise.

The ultimate guide to /goal

Shubham Saboo argues that /goal is not just a feature, but is emerging as a foundational primitive for coding agents, much like HTTP or JSON. With normal prompting, you steer turn by turn: read the response, evaluate it, and nudge the agent to the next step. /goal flips that model: you describe what “done” looks like, send it once, and the agent loops autonomously until it gets there — for example, “build the app according to SPEC.md; done means tests pass, build passes, README is accurate, and git status is clean.” It shifts the interaction from micromanaging steps to delegating against a clear objective. Notably, three separate ecosystems — OpenAI Codex CLI, Claude Code, and the Hermes Agent orchestrator — have converged on the same command pattern, making them composable.

Saboo outlines three enduring roles regardless of how tools evolve: the orchestrator that coordinates, selects workers, manages the Kanban board, and performs final verification (Hermes); the builder that takes a spec and generates code (Codex’s strength); and the reviewer that hunts for bugs in plausible-looking code (Claude Code’s strength). The golden rule is independent verification: Hermes never trusts Codex’s self-reported completion and instead runs npm test and npm run build itself — turning /goal from a promise into a contract. Multiple goals can run in parallel, though each file should only have a single writing agent at a time to avoid conflicts.

The AI-Native Developer

Brian Houck presents research on how AI is reshaping the developer role, drawing on a survey of more than 1,300 developers and interviews with 22 practitioners. Developer work falls into three buckets: core tasks like coding, debugging, and testing score high across every dimension and represent the biggest opportunity for AI; cross-component debugging and environment provisioning are areas where developers want deeper AI help, though current tools still fall short; and relational work like stakeholder communication sits in the “low priority for AI” zone where developers want to retain their own voice and final accountability.

The study identifies four stages of AI maturity: Skeptics, who adopt only when competitive pressure forces their hand; Explorers, who build confidence through small wins; Collaborators, who bring AI into their workflow much earlier; and Strategists, who orchestrate multiple agents in parallel, shifting from code producers to “architects of intent.” Alongside this progression sit three unresolved tensions: the learning paradox (are we becoming better engineers or just better prompt writers?), the risk of skill atrophy among junior developers, and an accountability gap when verification standards fail to keep pace with generation speed. Houck sketches three possible futures: maintaining deep craft at AI speed, focusing on orchestration and judgment, or becoming a “Clerical Coder” who rubber-stamps generated code without truly understanding it.


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.