Newsletter #125
Enjoy Newsletter #125.
275 - Khi Big Tech chuyển mình thành AI Factory
This edition shares an inside look at how a major tech company is transforming its engineering organization into an “AI factory.” The author maps agentic automation across five maturity levels: starting with engineers copy-pasting snippets from a chatbot, moving to interactive coding agents guided turn by turn, then agents going autonomously from a written spec to a tested pull request, then humans acting solely as orchestrators of review and deployment, and finally agents autonomously deploying, monitoring production, and remediating incidents. Because each level grants agents broader autonomy, the company has to invest heavily in sandboxed execution environments, automated verification, fine-grained permissions, and hard guardrails that block destructive actions.
As a result, the software engineer’s day-to-day role shifts from writing every line by hand to “packaging” work into well-bounded specifications with explicit goals and acceptance criteria—a transition that proves surprisingly tough for junior engineers accustomed to exploratory, trial-and-error coding. Human code review remains indispensable because critical product and system requirements often live in unwritten tribal context; automated AI review bots currently have only about half of their suggestions accepted and burn significant token budgets at scale. While individual programming languages are becoming increasingly interchangeable, deep fundamentals in operating systems, networking, security, infrastructure, data structures, and concurrency remain the bedrock that lets engineers evaluate and take accountability for AI-generated systems.
The 80/20 rule for your whole life
Yew Jin Lim proposes applying the 80/20 rule across your entire life: dedicate the 80% majority of your resources to building a rock-solid, low-drama foundation, and treat the remaining 20% as a “laboratory” for bounded experiments. The governing mindset is evaluating your life as a portfolio rather than agonizing over every individual position. He illustrates this with personal examples: many of the 20%-time side projects he tried at Google went nowhere individually, yet together they shaped his career trajectory; his retirement portfolio grew roughly tenfold through automated contributions and the discipline not to tinker; and his meditation practice deepened simply by showing up every day.
From that experience he distills three core habits: follow curiosity to expand your knowledge without demanding an immediate payoff, master decision-making by separating emotional reactions from individual outcomes, and stay consistent long enough for compounding to do its work. He draws a sharp distinction between short-term trading and long-term investing, noting that once your foundation is sound, “doing nothing” is often the highest-leverage move available. Experiments don’t need to succeed every time, so long as each bet is sized small enough that failure is cheap tuition rather than ruin—and the 80% foundation is never put at risk.
Three Bad Managers
Michael Lopp (Rands) tells the story of three brilliant, commercially successful bosses who were terrible people managers, using them to draw a crisp line between leadership (charting a compelling direction for the organization) and management (helping individuals understand where they stand and navigating day-to-day execution). “The Artist” was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. “The Dictator” used forceful authority and intimidation to dominate rooms—for instance, casually reopening design directions the team had already spent weeks evaluating rather than trusting their expertise. “The Knife” was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.
For each boss, Lopp found a different survival strategy: writing his own detailed performance review ahead of 1-on-1s so The Artist just had to react to it, doing exhaustive technical homework before meetings so he could push back on The Dictator as an equal, and simply staying out of The Knife’s blast radius to get work done independently. His core takeaway is that you will almost never change your boss—especially when they are senior and successful—but you can change how you prepare, communicate, and operate around them. Every working relationship requires calibration, and learning how to adapt to difficult personalities is a practical survival skill rather than an endorsement of bad management.
Cross-Team Pragmatics
Phil Calçado examines why cross-team collaboration almost always slows down and turns political as an engineering organization grows. The root causes are predictable: individual-focused performance review cultures incentivize local optimization, high-level strategic goals contradict each other once cascaded down different org branches (e.g., an infra team rewarded for cutting cloud spend while a product team is rewarded for shipping compute-heavy features), accountability is assigned without matching ownership, and minor disagreements constantly escalate up the management chain instead of getting resolved laterally. The only durable fix is a unified technical strategy that aligns how the business competes with team boundaries, ownership, incentives, and decision rights.
While waiting for those slow structural fixes to take hold, Calçado shares four pragmatic tools for treating the immediate symptoms. Team charters turn unspoken assumptions into explicit boundaries, responsibilities, and interaction modes, cutting down repetitive renegotiation. Value-stream mapping traces how a feature actually flows from idea to production rather than looking at the org chart, exposing unnecessary handoffs and queues. The 80% rule states that a team should be able to complete at least 80% of its roadmap without blocking dependencies on other teams along the critical path, while Team Topologies gives organizations a shared vocabulary for intentionally choosing how teams interact. These tools buy breathing room and stability, though long-term health still requires continuously reshaping the org around how value is actually delivered.
Technological Involution
Rohan argues that the tech industry has entered a state of “involution”: more talent and capital pouring in than ever, yet producing increasingly homogeneous, incremental ideas. In his view, the obvious low-hanging fruit of consumer and SaaS software has largely been picked, standard application software is rapidly commoditizing, and Silicon Valley startup culture encourages young founders to borrow pre-packaged narratives from influencers and VCs rather than forming independent convictions from scratch. Hype manufactures consensus rather than real value, while society at large grows more cynical about tech’s future. Meanwhile, the genuinely hard problems sit in atoms, hardware, semiconductors, and messy real-world enterprise operations—domains where most young founders lack hands-on experience.
AI excels at generating code and synthesizing conventional wisdom, but by design it gravitates toward the consensus mean rather than contrarian, high-impact insights. Rohan argues that this limitation is precisely what preserves the opening for human agency: people who immerse themselves deeply in a domain, test hypotheses from first principles, and have the courage to pursue non-consensus ideas will only become more valuable. The way out of involution is returning to intrinsic motivation—building something because the problem itself is intellectually gripping rather than optimizing for startup vanity metrics—and the success of independent, taste-driven new media proves that work built with genuine conviction still cuts through the noise.
Fintech Engineering Handbook
Wojciech Pitula’s handbook distills core principles and architectural patterns for building software where money is the primary domain object, anchored on three commandments: never invent money or data out of thin air, never lose data, and never trust any single component blindly. On representing monetary amounts, he compares floating-point numbers (almost never acceptable), arbitrary-precision decimals, integer minor units (e.g., cents), and rational fractions, while warning that standard JSON parsers silently coerce numeric literals into IEEE 754 floats unless amounts are serialized as strings or integers. Every balance change is recorded in a double-entry ledger where money only ever moves between accounts and balances are derived from immutable journal entries—tracking transaction time, booking time, and settlement time as distinct timestamps.
On the execution side, the handbook covers funds holds/reservations to prevent double-spending, strict idempotency keys, crash-resumable state machines, and at-least-once event delivery. When integrating with external payment processors and banks, systems must validate schemas at the boundary, persist every raw request and response payload for auditability, verify webhook signatures before querying the provider’s canonical API for state, and run independent automated reconciliation jobs to catch ledger drift early. Posted ledger entries are strictly immutable—mistakes are corrected via compensating reversal entries, never UPDATE or DELETE—and sensitive manual operations require four-eyes approval. End-to-end walkthroughs of crypto withdrawals, card top-ups, and currency exchanges show how these patterns interlock across multi-step failure scenarios.
How to Write an Effective Software Design Document
Michael Lynch shares a practical guide to writing software design documents that surface flawed assumptions before coding begins and align stakeholders on how to solve a problem. A design doc is worth writing when a project spans multiple people, takes longer than three months, will live in production long-term, crosses team boundaries, starts from ambiguous requirements, or carries high operational risk. To decide how much detail a section needs, Lynch suggests asking one simple question: “what is the cost of being wrong?” Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don’t belong in a design doc.
An effective design doc typically covers background and goals, explicit scope and non-goals, architecture and data-flow diagrams, measurable SLAs/SLOs, security and privacy considerations, a milestone timeline, and a log of open and resolved questions. The document should focus on the hardest trade-offs and gathering early feedback rather than specifying every line-level implementation detail—if you’ve written pseudocode for every class, you’ve essentially written the code twice. Lynch also recommends using editable diagramming tools (like Mermaid or Excalidraw with source checked in), defining domain jargon in a glossary, documenting rejected alternatives so reviewers don’t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.
The Cost YAGNI Was Never About
Kent Beck explains that YAGNI (“You Aren’t Gonna Need It”) was never really about saving typing or coding effort—it is an economic principle about when to commit to a design decision. Building speculative structure before a feature actually demands it incurs two distinct costs that have nothing to do with how fast you can write code. The first is lost optionality: the team locks in a bet when they have the least information about the problem, and when real requirements inevitably diverge from the guess, they have to pay to work around or rip out that speculative abstraction. Even on the rare occasion when the guess turns out right, committing early still forfeits the option value of waiting until you know more; as Beck puts it, waiting isn’t procrastination—it is holding a valuable option.
The second cost is net present value (NPV) and carrying cost: you pay the complexity, maintenance, and cognitive tax immediately while any hypothetical payoff arrives far in the future, meaning you lose economically whether your prediction was right or wrong. Now that AI makes generating code nearly free, the “save typing time” argument for YAGNI disappears, yet both the optionality cost and the carrying cost remain completely intact—in fact, AI makes it dangerously easy to hallucinate sprawling, speculative frameworks in seconds. Build structure when concrete demand arrives and gives you the information needed to design it right; YAGNI is economic discipline, not stinginess with keystrokes.
a CVE dispute
Daniel Stenberg recounts curl’s first formal CVE dispute since the project became a CVE Numbering Authority (CNA). With roughly 30 billion libcurl installations worldwide, publishing a CVE triggers a massive wave of triage, compliance scanning, patching, and backporting across the entire software industry. Because of that amplification effect, the curl security team evaluates reports based on realistic exploitability and occasionally declines to assign a CVE to bugs whose security impact is “lower than low”—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.
The disputed report involved curl’s wildcard certificate hostname matching function when the URL’s hostname began with a leading dot (e.g., .example.com). For this bug to be exploitable in practice, an absurd chain of preconditions had to hold simultaneously: a user had to request a hostname that is syntactically invalid in standard DNS, that invalid name had to resolve via something like a modified local /etc/hosts file, an attacker-controlled server at that IP had to present a matching wildcard certificate from a trusted CA, and the attacker already needed local privileges to poison name resolution in the first place. The curl team fixed the bug in December 2025 as a normal defect but declined to issue a CVE. A security researcher appealed the decision to MITRE, and after multiple rounds of review in 2026, MITRE agreed with curl that it was simply a fixed bug rather than a security vulnerability because exploiting it required a privileged local attacker. The episode illustrates why not every bug in a network library deserves a CVE, and how the CNA dispute process provides an independent check when opinions differ.
How LLMs Actually Work
This visual guide explains how autoregressive transformer language models generate text token by token without getting bogged down in heavy calculus. Incoming text is first split into subword tokens by a tokenizer and mapped to integer IDs; an embedding lookup table then converts each ID into a dense vector capturing learned semantic features, placing tokens with related meanings near one another in high-dimensional space. Because self-attention treats inputs as an unordered set by default, the model injects positional information—most modern LLMs use Rotary Position Embeddings (RoPE), rotating query and key vectors by an angle proportional to each token’s position in the sequence. Inside each transformer block, self-attention compares query vectors against key vectors to compute attention weights, deciding how much information to pull from each prior token’s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.
After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model’s parameters and stored factual associations. Residual connections allow information to flow and accumulate across dozens of stacked layers without vanishing gradients, while layer normalization keeps activation magnitudes stable. At the very end of the stack, the final token’s hidden state vector is projected across the entire vocabulary and passed through softmax to produce a probability distribution over the next token; the runtime samples a token (shaped by temperature, top-p, or top-k), appends it to the sequence, and repeats the loop. While modern frontier models tweak attention variants, architectures, and training recipes, they all share this foundational autoregressive transformer loop.
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.
Comments