Enjoy Newsletter #97.

Why we’re rethinking cache for the AI era

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.

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.

A Behind-the-Scenes Look at How We Release the Spotify App (Part 1)

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.

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.

Components of A Coding Agent

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’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.

The article breaks a coding agent down into six core components. First is live repo context: gathering directory structure, Git status, and project instructions before acting on a prompt. Second is prompt prefix caching: 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 structured tool access: 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 context compaction: truncating giant tool outputs, deduplicating repeated file reads, and summarizing old turns to prevent context bloat. Fifth is structured session memory: maintaining both a full on-disk transcript and a compact working memory so long sessions stay sharp and resumable. Sixth is bounded subagents: letting the primary agent delegate subtasks to scoped worker agents with isolated context windows, enabling parallel execution without losing control.

Say the Thing You Want

The author of Terrible Software 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 “anything else?”, countless engineers say “nope, all good” even when they badly want to lead the next project, get promoted, or switch teams—afraid of sounding entitled, being told they aren’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 “zero surface area”—nobody can react to it, build on it, or help you reach it.

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 “I want to lead a project” 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’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.

Agentic Coding and Microservices

Nate Meyvis responds to Ben Borgers’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 always helped humans, teams, and agents alike, and isn’t unique to AI. In fact, coding with AI has pushed his own projects more 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.

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 AGENTS.md 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.

Garbage Collection: From First Principles to Modern Collectors in Java, Go and Python

This comprehensive guide traces garbage collection from its theoretical roots—starting with John McCarthy’s 1960 Lisp paper introducing mark-and-sweep—up through modern collectors in Java, Go, and Python. Following Paul Wilson’s classic 1992 survey taxonomy, automatic memory management rests on three foundational families: mark-and-sweep (simple, but fragments the heap), semi-space copying (copies live objects into a fresh half-heap, enabling fast bump-pointer allocation at the cost of reserving half of memory), and reference counting (frees memory deterministically as soon as the count hits zero, but struggles with cyclic references). The weak generational hypothesis—“most objects die young”—underpins modern collectors that focus collection effort on a small young generation to dramatically cut pause times.

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’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 (colored pointers) 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’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’s avoid pointer updates and accept more complex free-list/span allocation instead.

I told Claude Code to build me an executive assistant

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’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.

The secret is that he “never thinks about the system”: 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 "morning sync" to synthesize his calendar and top priorities, "prep for 1:1 with Daniel" to review past notes and surface talking points, and "log decision about X" 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’s conclusion: every knowledge worker will eventually run a personal agent harness like this, and those who wait will fall behind.

Bonus

Images: Monolithic vs Microservices vs Serverless CLI vs MCP Comparing 5 Major Coding Agents JWT Visualized


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.