Newsletter #53
For this post, I experimented with consolidating all my previous coding agent rules into a single Enjoy Newsletter #53.AGENTS.md file, then pointing CLAUDE.md to read that file.
Anti-cheat, Secure Boot & TPM
Andrew Moore explains why anti-cheat systems like those in Battlefield 6 or Riot’s Vanguard have started requiring players to enable Secure Boot and TPM 2.0, while pushing back against claims that this is a pretext for harvesting player data. Secure Boot relies on a key hierarchy (Platform Key, Key Exchange Key, the DB allowlist of signatures, and the DBX blocklist) to ensure firmware only executes validly signed boot images. Combined with Windows only loading Microsoft-signed kernel drivers, cheat developers have a hard time injecting code into the kernel without an unpatched vulnerability.
However, an anti-cheat client cannot simply trust the operating system when it reports that Secure Boot is enabled, which is where the TPM becomes the crucial link. The firmware TPM (fTPM) built into modern AMD and Intel CPUs holds a unique Endorsement Key backed by a manufacturer certificate, providing unforgeable hardware identification—meaning a hardware ban forces a cheater to buy a new CPU. In addition, the TPM’s PCR registers record a cryptographic hash chain of every event during the boot sequence, and through remote attestation via TPM2_Quote, the anti-cheat server can verify that the boot environment has not been tampered with. The takeaway: this setup doesn’t eliminate cheating completely—especially hardware-based cheats—but it makes ban evasion far more expensive, doesn’t compromise user privacy, and forms an important layer of defense in depth.
Left to Right Programming
The author argues that a program should remain syntactically valid while it is being typed from left to right, so the editor can offer autocomplete and type checking at every step. A classic counterexample is Python’s list comprehension: when writing words_on_lines = [line.split() for line in text.splitlines()], the variable line is used before it is declared, so the editor doesn’t know its type when you type the dot and cannot suggest methods. By contrast, in Rust (let words_on_lines = text.lines().map(|line| line.split_whitespace());) or JavaScript, expressions are built from left to right: the source is stated first, and the moment you type a dot, the editor can suggest relevant methods.
The article connects this to the design principle of “progressive disclosure”: complexity should only surface when the user actually needs it. In C, because methods cannot be attached to structs, you have to know function names like fread or fclose ahead of time rather than discovering them through autocomplete after typing file.. Python runs into a similar issue with global functions like len or map; as logic grows more complex, a single line of Python nesting multiple filter, lambda, and comprehension expressions becomes much harder to read than a method chain in JavaScript that reads sequentially from left to right. The closing message for language and library designers is simple: build discoverable APIs.
Big O Notation
This interactive guide on samwho.dev introduces Big O notation visually with live in-browser examples. Rather than measuring wall-clock time, Big O describes how execution time grows as input size increases. The author walks through four common complexity classes: summing numbers from 1 to n with a loop is O(n) (linear), whereas using the formula (n*(n+1))/2 is O(1) (constant)—noting that O(1) does not mean “instant,” only that runtime does not depend on input size. Bubble sort illustrates O(n²) (quadratic), while guessing a number between 1 and 100 via binary search, halving the search space on each guess, illustrates O(log n) (logarithmic). Big O describes an asymptotic upper bound: O(2n) simplifies to O(n), keeping only the fastest-growing term. You can analyze best, average, or worst cases; the article focuses on the worst case.
The final section shares practical performance tips: use a hash-table-backed Set for average O(1) lookups instead of scanning an array (even though building the Set costs O(n)), avoid calling .indexOf inside a loop since that quietly turns the whole function into O(n²), and memoize intermediate results—as shown with factorials—to avoid redundant computation at the cost of extra memory. The most important advice: always benchmark before and after changing code, and don’t blindly trust performance claims you read online.
Personal AI Evaluations August 2025
Graham King evaluates large language models (LLMs) against his own day-to-day needs instead of relying on public leaderboards: he selected 12 questions out of 130 prompts from his bash history across four categories (coding, sysadmin, technical explanations, and general knowledge/creative), and ran them against 11 models via OpenRouter—including Claude Sonnet 4, DeepSeek, Gemini 2.5 Flash and Pro, Kimi K2, GPT-OSS-120B, Qwen3, and GLM 4.5. He wrote a custom Rust tool to anonymize the responses for blind grading while recording cost, latency, and throughput for each model.
His main conclusion is that almost all current models give good answers, making cost and latency the deciding factors. Proprietary models like Gemini 2.5 Pro and Claude Sonnet did not stand out—in fact, they often scored lower than open-weight models while costing dramatically more. Gemini 2.5 Flash was the fastest; Kimi K2, Qwen3, and DeepSeek were among the cheapest; and two DeepSeek models alongside two Qwen3 models achieved the highest average accuracy. Reasoning mode rarely helped outside of a poetry prompt, and the entire evaluation produced only a single hallucination, when GPT-OSS-120B invented a nonexistent movie. Based on these results, the author now queries multiple models in parallel using tmux: DeepSeek for everyday questions, adding Gemini Flash and Qwen3 when he wants a second opinion, and reserving reasoning models for particularly tough problems.
How to Keep Services Running During Failures
This post from The Scalable Thread introduces graceful degradation, the design principle of keeping a system’s core functionality running when a component fails rather than letting the entire service go down. For example, if a video platform’s recommendation service fails, the homepage can fall back to showing trending videos while video playback continues working normally. The first group of strategies focuses on traffic control: rate limiting caps incoming requests during flash sales or DDoS attacks; request coalescing collapses thousands of identical concurrent queries into a single database hit; load shedding proactively drops non-essential requests (such as click tracking) to preserve capacity for checkout transactions; and retries with jitter add random backoff delays to prevent a “thundering herd problem” when a recovering service comes back online.
The second group of strategies handles faults and improves observability. A circuit breaker acts like an electrical breaker: when a payment service repeatedly fails, the ordering service trips the breaker and fails fast for a cooldown period (say, 60 seconds) before letting a few probe requests through to check whether the downstream service has recovered. Request timeouts prevent upstream services from exhausting thread pools or connection limits waiting on a slow dependency. Finally, monitoring and alerting on metrics like error rates, latency, and message broker queue depth help engineers catch and contain incidents before they cascade.
Why Was Apache Kafka Created?
This article from 2 Minute Streaming explains why Kafka was created in the first place. Around 2012, LinkedIn relied on user activity data to power many core features, but operated two separate data pipelines: an hourly batch system that pushed XML messages through HTTP servers into Oracle and Hadoop data warehouses, and a near-real-time monitoring pipeline built on Zenoss. Both required heavy manual operations, suffered from large backlogs, and consisted of fragile point-to-point connections that couldn’t be unified. Specific pain points included parsing hundreds of XML schemas, breaking downstream consumers whenever a schema changed, multi-hour latency, and clean data being locked inside the data warehouse.
Kafka solved these problems with a distributed, replicated architecture that scales horizontally via partitions, an append-only log structure that supports multiple independent consumers, and disk persistence that decouples producers from consumers. LinkedIn also migrated from XML to Avro (roughly 7x smaller), built a schema versioning service—the precursor to Schema Registry—with backward-compatibility checks, enforced “schema on write” to validate data before it entered Kafka, and shifted schema ownership to the teams producing the data backed by mandatory review workflows. What surprised the author most is that LinkedIn’s original papers emphasized schemas over 13 years ago, whereas he considers the lack of native, built-in schema enforcement to be Kafka’s biggest design mistake.
How We Vibe Code at a FAANG
A Reddit user who introduces himself as an AI engineer with over ten years of experience—roughly half of it at FAANG or similar companies—shares how his team integrates AI into a production software development workflow, pushing back against the claim that AI-assisted coding isn’t viable for real-world systems. Their process still starts with rigorous technical design docs: a proposal must win stakeholder alignment, followed by a full system design covering architecture and cross-team integrations, and then a design review where senior engineers tear it apart—what the author calls front-loading the pain. Next come subsystem documentation, task breakdowns, and sprint planning with PMs and TPMs.
Only when it is time to write code does AI become a productivity “force multiplier”: the team practices Test-Driven Development, having AI agents write the tests first before implementing the feature. Every pull request still requires approval from two human engineers before merging (with AI also starting to assist in code reviews), followed by staging verification before production rollout. According to the poster, end-to-end delivery time from feature proposal to production is about 30% faster. Many commenters pointed out that this isn’t really “vibe coding” at all, but disciplined AI-assisted engineering inside a mature enterprise workflow—a distinction the author himself agreed with.
Verdict on AGENTS.md effectiveness: Not great yet—it still left quite a lot of English terms untranslated. I’ll try to refine it further in upcoming posts. See you next time!
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