<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>AI on miti99</title><link>https://miti99.com/en/tags/ai/</link><description>Recent content in AI on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/ai/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #125</title><link>https://miti99.com/en/post/2026/07/13/</link><pubDate>Mon, 13 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #125.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="275---khi-big-tech-chuyển-mình-thành-ai-factory"&gt;&lt;a href="https://newsletter.grokking.org/p/275-khi-big-tech-chuyen-minh-thanh" rel="noopener noreferrer"&gt;275 - Khi Big Tech chuyển mình thành AI Factory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This edition shares an inside look at how a major tech company is transforming its engineering organization into an &amp;ldquo;AI factory.&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;As a result, the software engineer&amp;rsquo;s day-to-day role shifts from writing every line by hand to &amp;ldquo;packaging&amp;rdquo; 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.&lt;/p&gt;
&lt;h2 id="the-8020-rule-for-your-whole-life"&gt;&lt;a href="https://yewjin.substack.com/p/always-be-curious" rel="noopener noreferrer"&gt;The 80/20 rule for your whole life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &amp;ldquo;laboratory&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;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, &amp;ldquo;doing nothing&amp;rdquo; is often the highest-leverage move available. Experiments don&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="three-bad-managers"&gt;&lt;a href="https://randsinrepose.com/archives/three-bad-managers/" rel="noopener noreferrer"&gt;Three Bad Managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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). &amp;ldquo;The Artist&amp;rdquo; was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. &amp;ldquo;The Dictator&amp;rdquo; 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. &amp;ldquo;The Knife&amp;rdquo; was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="cross-team-pragmatics"&gt;&lt;a href="https://philcalcado.com/2026/06/01/cross_team_pragmatics.html" rel="noopener noreferrer"&gt;Cross-Team Pragmatics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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.&lt;/p&gt;
&lt;p&gt;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.&lt;/p&gt;
&lt;h2 id="technological-involution"&gt;&lt;a href="https://rohan.ga/blog/technological-involution/" rel="noopener noreferrer"&gt;Technological Involution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rohan argues that the tech industry has entered a state of &amp;ldquo;involution&amp;rdquo;: 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&amp;rsquo;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.&lt;/p&gt;
&lt;p&gt;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.&lt;/p&gt;
&lt;h2 id="fintech-engineering-handbook"&gt;&lt;a href="https://w.pitula.me/fintech-engineering-handbook/" rel="noopener noreferrer"&gt;Fintech Engineering Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wojciech Pitula&amp;rsquo;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.&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;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 &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt;—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.&lt;/p&gt;
&lt;h2 id="how-to-write-an-effective-software-design-document"&gt;&lt;a href="https://refactoringenglish.com/excerpts/write-an-effective-design-doc/" rel="noopener noreferrer"&gt;How to Write an Effective Software Design Document&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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: &amp;ldquo;what is the cost of being wrong?&amp;rdquo; Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don&amp;rsquo;t belong in a design doc.&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;ve written pseudocode for every class, you&amp;rsquo;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&amp;rsquo;t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.&lt;/p&gt;
&lt;h2 id="the-cost-yagni-was-never-about"&gt;&lt;a href="https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-about" rel="noopener noreferrer"&gt;The Cost YAGNI Was Never About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck explains that YAGNI (&amp;ldquo;You Aren&amp;rsquo;t Gonna Need It&amp;rdquo;) was never really about saving typing or coding effort—it is an economic principle about &lt;em&gt;when&lt;/em&gt; 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&amp;rsquo;t procrastination—it is holding a valuable option.&lt;/p&gt;
&lt;p&gt;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 &amp;ldquo;save typing time&amp;rdquo; 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.&lt;/p&gt;
&lt;h2 id="a-cve-dispute"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/06/24/a-cve-dispute/" rel="noopener noreferrer"&gt;a CVE dispute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg recounts curl&amp;rsquo;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 &amp;ldquo;lower than low&amp;rdquo;—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.&lt;/p&gt;
&lt;p&gt;The disputed report involved curl&amp;rsquo;s wildcard certificate hostname matching function when the URL&amp;rsquo;s hostname began with a leading dot (e.g., &lt;code&gt;.example.com&lt;/code&gt;). 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 &lt;code&gt;/etc/hosts&lt;/code&gt; 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.&lt;/p&gt;
&lt;h2 id="how-llms-actually-work"&gt;&lt;a href="https://www.0xkato.xyz/how-llms-actually-work/" rel="noopener noreferrer"&gt;How LLMs Actually Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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&amp;rsquo;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&amp;rsquo;s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.&lt;/p&gt;
&lt;p&gt;After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model&amp;rsquo;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&amp;rsquo;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.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LlLN!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe4d255e1-536e-4f66-ab48-e8baa1bdd4a4_2484x3002.png" alt="RAG vs Graph RAG vs Agentic RAG"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!15Bw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9b8f9d64-3eae-4237-b49f-ffde033f851a_2484x3002.png" alt="Redis Data Structures Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-ILW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F19ca7f08-d615-4769-8599-2aa9aaa5d6bd_2508x3000.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ydOn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe46aad28-2935-4b87-8cf4-72787b48a9d0_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_6cl!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fea738d9d-1ae5-4a26-9a50-79ec7720fd80_2360x2664.jpeg" alt="The Testing Pyramid"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #123</title><link>https://miti99.com/en/post/2026/07/11/</link><pubDate>Sat, 11 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #123.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="our-collective-bike-shed-moment"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/our-collective-bike-shed-moment.html" rel="noopener noreferrer"&gt;Our Collective Bike Shed Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post borrows Parkinson&amp;rsquo;s &amp;ldquo;Law of Triviality&amp;rdquo;: a fictional committee approves a nuclear reactor design in ten minutes because the topic is too complex for anyone to debate, then spends forty-five minutes arguing over what color to paint the bike shed. The author argues that society is re-enacting that exact meeting in the face of AI. LLMs have blown past one supposed ceiling after another—from &amp;ldquo;they can&amp;rsquo;t write real code&amp;rdquo; to hallucinations—while growing steadily stronger at formal methods and multi-step reasoning, yet critics keep moving the goalposts while the broader public carries on as if nothing fundamental has changed.&lt;/p&gt;
&lt;p&gt;Demirbas attributes this collective shrug to normalcy bias—our default assumption that tomorrow will look mostly like yesterday—and Douglas Adams&amp;rsquo;s &amp;ldquo;Somebody Else&amp;rsquo;s Problem&amp;rdquo; field, where something colossal is ignored precisely because it is too big to process. Learning new AI tools to stay employable over the next few years is a sensible personal strategy, but it doesn&amp;rsquo;t answer what happens over the coming decades. What worries the author is that even the people who should be leading the serious conversation—technologists, researchers, economists, policymakers, ethicists, defense planners, and educators—still aren&amp;rsquo;t grappling with the long-term societal transformation at the depth required, while public attention remains fixated on surface-level bike-shedding.&lt;/p&gt;
&lt;h2 id="p99-0ms"&gt;&lt;a href="https://ruurtjan.com/articles/p99-0ms-autocomplete-for-240-million-domain-names" rel="noopener noreferrer"&gt;p99 0 ms* autocomplete for 240 million domain names&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ruurtjan Pul explains how Wirewiki achieves instantaneous-feeling autocomplete across a dataset of 240 million domain names. The trick starts in the browser: on &lt;code&gt;keydown&lt;/code&gt;, the client prefetches autocomplete results not only for the current prefix, but for every valid character the user might type next; by the time the next &lt;code&gt;keyup&lt;/code&gt; fires, the suggestions are already sitting in browser memory ready to render. Because domain names use a tiny character set (38 characters), a single response bundling top suggestions for all possible next keystrokes contains at most 312 domain names—roughly 2.5 kB compressed. According to the author&amp;rsquo;s measurements, 99% of keystrokes have at least a 121 ms budget before release, so &amp;ldquo;p99 0 ms&amp;rdquo; means the result is already local before &lt;code&gt;keyup&lt;/code&gt;, not that network packets travel faster than light.&lt;/p&gt;
&lt;p&gt;On the server side, the dataset is split into two tiers. An in-memory prefix tree (trie) holds the top eight suggestions for every prefix drawn from the Tranco top one million domains. The remaining 240 million domains from ICANN&amp;rsquo;s CZDS are sorted, front-coded (prefix-compressed), and packed into fixed-size blocks on SSD; a 27 MB in-memory index locates the right block in one hop while the OS page cache keeps hot blocks in RAM. The Go API typically responds in ~2 ms, and under 1,600 requests/sec Nginx plus the API still maintain a ~15 ms p99. Once the origin server is that fast, network round-trip time through Cloudflare dominates perceived latency—hence the asterisk in the title: a single European server still can&amp;rsquo;t beat the 121 ms budget for users halfway across the globe. The takeaway is to measure latency from the user&amp;rsquo;s physical interaction rather than just server processing time.&lt;/p&gt;
&lt;h2 id="building-reliable-agentic-ai-systems"&gt;&lt;a href="https://martinfowler.com/articles/reliable-llm-bayer.html" rel="noopener noreferrer"&gt;Building Reliable Agentic AI Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article on Martin Fowler&amp;rsquo;s site chronicles how Bayer built PRINCE, an agentic AI platform that helps pharmaceutical researchers query decades of preclinical toxicology data locked inside thousands of PDF study reports. The architecture evolved through three stages: structured metadata search, basic RAG question-answering, and finally a multi-agent workflow for complex cross-study questions. Orchestrated with LangGraph, the system steps through intent clarification, planning, research execution, evidence sufficiency checks, and report synthesis. Specialized research agents combine OpenSearch-backed RAG over unstructured PDF narratives with Athena Text-to-SQL for filtering, aggregating, and comparing structured study tables, while dedicated reflection nodes audit progress, data completeness, and draft quality.&lt;/p&gt;
&lt;p&gt;Reliability comes from the engineering harness around the models rather than clever prompting or waiting for a smarter foundation model. Each graph node receives only the narrow slice of context it needs; workflow state is checkpointed after every node so failures resume from the last completed step instead of restarting from scratch; and bounded retries operate at both the individual model-call level and the graph-node level, failing over to backup models or cloud regions when needed. In a heavily regulated pharmaceutical environment, user trust also depends on surfacing intermediate reasoning steps, linking every claim directly to source PDF pages and paragraphs, running continuous evaluations against both golden datasets and production traffic, and keeping domain scientists in the loop. Breaking a monolith prompt into an observable, checkpointed graph made the system dramatically easier to test, recover, and improve.&lt;/p&gt;
&lt;h2 id="growing-as-an-engineer-in-a-world-of-ai"&gt;&lt;a href="https://nlopes.dev/writing/growing-as-an-engineer-in-a-world-of-ai" rel="noopener noreferrer"&gt;Growing as an engineer in a world of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Norberto Lopes argues that the biggest risk AI poses to early-career engineers isn&amp;rsquo;t replacing their jobs—it&amp;rsquo;s short-circuiting their growth by removing the very friction that produces deep learning. Reading documentation, experimenting, failing, debugging, and piecing together your own mental model builds durable knowledge through &amp;ldquo;desirable difficulty&amp;rdquo; and the generation effect. Getting an instant answer is not the same as understanding the problem: if an engineer simply accepts generated code and moves on to the next ticket, they can ship working features while remaining unable to explain the design choices, trade-offs, or failure modes. That &amp;ldquo;cognitive debt&amp;rdquo; stays hidden until production breaks in a way the AI can&amp;rsquo;t immediately fix.&lt;/p&gt;
&lt;p&gt;Lopes doesn&amp;rsquo;t advocate shunning AI; instead, he recommends using it deliberately as a learning amplifier: ask &lt;em&gt;why&lt;/em&gt; an approach works, ask for alternative designs and failure scenarios, read the code and sketch your own mental model before asking the LLM to explain it, type out critical sections yourself instead of copy-pasting, and treat code review and technical writing as active thinking exercises. Foundational depth still comes from books, Unix fundamentals, primary specifications, architecture debates, and postmortems—and the time saved by AI should be reinvested into harder engineering thinking. Developing junior engineers is also an organizational responsibility: managers must protect space for learning, evaluate judgment and system understanding rather than raw ticket velocity, and keep hiring and mentoring the next generation.&lt;/p&gt;
&lt;h2 id="note-to-my-younger-self"&gt;&lt;a href="https://yewjin.substack.com/p/note-to-my-younger-self" rel="noopener noreferrer"&gt;Note To My Younger Self&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reflecting on two decades at major tech companies, Yew Jin Lim distills eight career principles that sound simple on paper but take discipline to practice. Fall in love with the actual craft rather than chasing titles, and treat your first job as a laboratory for learning how to solve problems; keep asking &amp;ldquo;why&amp;rdquo; until you reach root causes; build genuine relationships by helping people without keeping score while maintaining healthy boundaries; bring energy and joy to the team around you; listen carefully, tailor explanations to your audience, and know when to stay quiet; write down your impact every single week and proactively ask for specific feedback—then act on it visibly—so you have a concrete record of growth and course-correct early; and whenever you have a choice, optimize for a manager who will invest in your growth over a flashier title, because a great manager shapes how you think for the rest of your career.&lt;/p&gt;
&lt;p&gt;Lim candidly acknowledges survivorship bias and notes that none of these rules are absolute. When good work, a supportive manager, kindness, visibility, and mental health come into conflict, the right trade-off depends on your career stage, the skills you still need to build, personal circumstances, and how long a situation will last. When torn between options, a clarifying question is: what will still matter five years from now? Individual projects are almost always forgotten, whereas skills, mental models, and strong relationships keep compounding for decades.&lt;/p&gt;
&lt;h2 id="google-hits-50-ipv6"&gt;&lt;a href="https://blog.apnic.net/2026/04/28/google-hits-50-ipv6/" rel="noopener noreferrer"&gt;Google hits 50% IPv6&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In April 2026, Google&amp;rsquo;s public telemetry crossed the milestone of 50% of users connecting over IPv6, underscoring that IPv6 is now a mature pillar of the global Internet. At the same time, APNIC Labs measured global IPv6 adoption around 42%, and Geoff Huston explains why that gap isn&amp;rsquo;t a contradiction. APNIC&amp;rsquo;s measurement samples run via online ad placements whose impression volume varies across countries, and those per-economy numbers are then weighted by UN/ITU estimates of each country&amp;rsquo;s total Internet population—meaning the global aggregate depends heavily on sample distribution and weighting methodology. At the individual country level, APNIC&amp;rsquo;s figures track closely with Google&amp;rsquo;s and other measurement sources, making the 42%–50% range a solid band for global deployment.&lt;/p&gt;
&lt;p&gt;IPv6 adoption remains wildly uneven across regions, fixed-line ISPs, and mobile carriers. Slow migration doesn&amp;rsquo;t necessarily mean failure: many established ISPs are still amortizing heavy capital investments in IPv4 and CGNAT gear, whereas rapidly growing mobile networks often adopt IPv6 from day one to lower total cost of ownership—making transition a question of capital cycles and market economics rather than pure protocol superiority. Today&amp;rsquo;s Internet operates as a permanent dual-stack/translation hybrid across direct IPv4, NAT/CGNAT IPv4, and native IPv6, so clinging to IPv4 doesn&amp;rsquo;t avoid complexity either. Increasingly, interoperability is absorbed at the edge by CDNs, cloud load balancers, and dual-stack transit providers rather than requiring every backend system on earth to cut over simultaneously.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://www.manager.dev/newsletter/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post collects seven operational laws that engineers usually only internalize the hard way after living through production outages. First: if production breaks right after a deploy, roll back immediately (if safe to do so) to restore service and investigate afterward, instead of burning precious minutes trying to prove your commit couldn&amp;rsquo;t possibly be the cause. Second: backups don&amp;rsquo;t exist until you regularly test restoring from them, and the team knows the exact RPO, RTO, and who has permissions to run the restore. Third: logs must carry enough context and a cross-service correlation ID to trace a request end to end without drowning operators in noise.&lt;/p&gt;
&lt;p&gt;Fourth: every database migration must have a fast, concrete, pre-tested rollback plan before it touches production. Fifth: every external dependency will eventually be slow, rate-limit you, or go down completely, so understand its rate limits, failure impact, and SLAs up front and build fallbacks like caching, queues, or serving stale data. Sixth: use the four-eyes principle for risky manual operations in production—if you feel hesitant to wake a teammate up at 2 a.m. to double-check a command, that is the clearest sign you shouldn&amp;rsquo;t be running it alone. Finally, nothing is more permanent than a temporary hack, so even an MVP must be simple and solid enough to live with for years rather than a fragile patch you promise to clean up later.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!mGbr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8558b1b2-984f-4c42-bb23-e63a2252533c_2650x3068.png" alt="Top Anti-Patterns in Service Architecture"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #109</title><link>https://miti99.com/en/post/2026/06/06/</link><pubDate>Sat, 06 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #109.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-history-of-ides-at-google"&gt;&lt;a href="https://laurent.le-brun.eu/blog/a-history-of-ides-at-google" rel="noopener noreferrer"&gt;A History of IDEs at Google&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurent Le Brun, who spent 12 years working on developer tooling at Google, recounts the journey from a fragmented ecosystem of editors to a single IDE used by nearly the entire company. Back in 2011, when someone asked whether Google should standardize on one IDE, the near-unanimous answer was &amp;ldquo;no&amp;rdquo; — Jeff Dean argued that forcing a whole team onto a single editor was a recipe for misery. The price of that freedom was that every useful integration — Bazel, code search, formatters — had to be rebuilt for every editor. Around 2013, Cider launched as a web-based editor initially meant for quick doc edits, but thanks to a backend capable of indexing Google&amp;rsquo;s massive monorepo, it gradually won over Go and then Java developers.&lt;/p&gt;
&lt;p&gt;In 2020, the team decided to replace Cider&amp;rsquo;s custom frontend with the VS Code core while keeping Google&amp;rsquo;s proprietary backend; Cider V opened to 5,000 engineers in 2021 and accounted for roughly 80% of main-repo development by 2023. Once most engineers shared a single platform, teams had strong incentives to build internal extensions — roughly 100 within two years — and AI features like code completion and automated review-comment resolution could be rolled out company-wide far faster. The takeaway: standardizing tooling creates massive leverage, even if the up-front investment is high and not every company can pull it off.&lt;/p&gt;
&lt;h2 id="finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks"&gt;&lt;a href="https://medium.com/pinterest-engineering/finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks-ea4722e552eb" rel="noopener noreferrer"&gt;Finding zombies in our systems: A real-world story of CPU bottlenecks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In early 2025, Pinterest&amp;rsquo;s Ray ML training jobs kept crashing due to flaky network connections, and it took the Kubernetes platform team over three months to track down the culprit. The first clue was that the EC2 ENA network driver reset itself whenever its transmit queue stalled for more than 5 seconds, a classic symptom of CPU starvation; weirdly, the resets only happened in a single availability zone even though cluster configs looked identical, and rebooting nodes only bought about a week of relief. On 96-vCPU GPU instances, aggregate &lt;code&gt;perf&lt;/code&gt; profiles looked completely normal; only per-core, per-second &lt;code&gt;mpstat&lt;/code&gt; monitoring revealed a single CPU core pinned at 100% system time for several seconds right when each reset occurred. The team set up automated 2-minute &lt;code&gt;perf record&lt;/code&gt; captures and used Netflix&amp;rsquo;s Flamescope to scrub to the exact second of the spike.&lt;/p&gt;
&lt;p&gt;The culprit: right before every reset, &lt;code&gt;kubelet&lt;/code&gt; spiked to ~6.5% total CPU (normally under 1%), spending nearly all of that time inside the kernel&amp;rsquo;s &lt;code&gt;mem_cgroup_nr_lru_pages&lt;/code&gt; function. The kernel was tracking nearly 70,000 memory cgroups even though only 240 were actually active — &amp;ldquo;zombie memcgs&amp;rdquo; — and walking that list pinned a single core long enough to starve the network driver thread sharing it. The root cause traced back to the AWS Deep Learning AMI (Ubuntu 20.04) base image, which shipped with the Amazon ECS agent enabled by default; unable to join an ECS cluster, the agent crashed in a tight loop, leaking a zombie cgroup on every restart. The fix was simple: disable the ECS agent systemd unit and reboot the fleet. As for why the &amp;ldquo;healthy&amp;rdquo; availability zone never broke? Another bug there prevented the ECS agent from ever starting in the first place.&lt;/p&gt;
&lt;h2 id="programming-still-sucks"&gt;&lt;a href="https://www.stvn.sh/writing/programming-still-sucks-fqffhyp" rel="noopener noreferrer"&gt;Programming Still Sucks.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steven Langbroek wrote this essay to answer the familiar question &amp;ldquo;Will AI take programmers&amp;rsquo; jobs?&amp;rdquo;, and his answer is no: the real culprit is greed, merely dressed up in a new coat called &amp;ldquo;automation.&amp;rdquo; Starting from a casual question at a birthday party, he paints software engineering as a burning ship: no map, no crew, sails mounted backward, useless navigation instruments, and a predecessor who abandoned ship after leaving behind half-baked &amp;ldquo;initiatives.&amp;rdquo; Layoffs, he argues, are signed off by people who know the consequences full well but bow to spreadsheets and quarterly targets, telling themselves they&amp;rsquo;ll &amp;ldquo;fix it later&amp;rdquo; — a &amp;ldquo;later&amp;rdquo; that never comes.&lt;/p&gt;
&lt;p&gt;The sharpest pain point is what happens to junior developers. A junior&amp;rsquo;s value isn&amp;rsquo;t the code they write today, but the fact that one day they become the senior who understands every dark corner of the system; eliminate apprenticeships to optimize short-term output, and a few years later there is nobody left to take the helm. The emotional heart of the piece is Sara, an older infrastructure specialist who inherited her knowledge from Ben and keeps the company alive via a mysterious cron job nobody else understands. When Sara retires, the company will desperately need a replacement after having dismantled the very pipeline that could have trained one. The disaster, Langbroek concludes, isn&amp;rsquo;t technological — it&amp;rsquo;s organizations actively sabotaging themselves.&lt;/p&gt;
&lt;h2 id="how-container-filesystem-works-building-a-docker-like-container-from-scratch"&gt;&lt;a href="https://labs.iximiuz.com/tutorials/container-filesystem-from-scratch" rel="noopener noreferrer"&gt;How Container Filesystem Works: Building a Docker-like Container From Scratch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ivan Velichko&amp;rsquo;s tutorial on iximiuz Labs builds a container by hand using nothing but standard Linux tools like &lt;code&gt;unshare&lt;/code&gt;, &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;pivot_root&lt;/code&gt; — not to replace Docker, but to give readers a clear mental model of what happens under the hood of &lt;code&gt;docker run&lt;/code&gt;. The foundation is the mount namespace: it isolates the mount table — the list of mounted filesystems visible to a process — rather than the underlying physical filesystem itself, something you can verify with &lt;code&gt;findmnt&lt;/code&gt; across two namespaces. Velichko emphasizes mount propagation across &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;shared&lt;/code&gt;, and &lt;code&gt;slave&lt;/code&gt; modes: if ignored, mounts created inside a container can leak out to the host, and &lt;code&gt;pivot_root&lt;/code&gt; — the safer alternative to &lt;code&gt;chroot&lt;/code&gt; — requires that the parent mount not be marked &lt;code&gt;shared&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough mirrors what &lt;code&gt;runc&lt;/code&gt; actually does: prepare a rootfs directory from an Alpine image; create mount, pid, cgroup, uts, and net namespaces; mount the &lt;code&gt;/proc&lt;/code&gt;, &lt;code&gt;/dev&lt;/code&gt;, and &lt;code&gt;/sys&lt;/code&gt; pseudo-filesystems with appropriate restrictions; bind-mount container-specific &lt;code&gt;/etc/hosts&lt;/code&gt;, &lt;code&gt;/etc/hostname&lt;/code&gt;, and &lt;code&gt;/etc/resolv.conf&lt;/code&gt; files; swap the root filesystem via &lt;code&gt;pivot_root&lt;/code&gt;; and harden the container by remounting sensitive &lt;code&gt;/proc&lt;/code&gt; paths read-only and masking others with &lt;code&gt;tmpfs&lt;/code&gt; or &lt;code&gt;/dev/null&lt;/code&gt;. On the security side, an untrusted rootfs can contain symlinks pointing outside the container, so production runtimes use &lt;code&gt;openat2()&lt;/code&gt; with &lt;code&gt;RESOLVE_NO_SYMLINKS&lt;/code&gt; and operate via file descriptors to prevent TOCTTOU race conditions. Finally, bind mounts are the exact same mechanism powering Docker&amp;rsquo;s &lt;code&gt;-v&lt;/code&gt; flag when sharing host volumes with a container.&lt;/p&gt;
&lt;h2 id="using-ai-to-write-better-code-more-slowly"&gt;&lt;a href="https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/" rel="noopener noreferrer"&gt;Using AI to write better code more slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amid the &amp;ldquo;vibe coding&amp;rdquo; frenzy, Nolan Lawson asks the opposite question: if so many people are using LLMs to crank out sloppy code as fast as possible, can we use the exact same tools to write better code more slowly? His answer is yes. His workflow centers on multi-model code review: having Claude, Codex, and Cursor Bugbot independently review a pull request, rank issues as critical, high, medium, or low, and then manually synthesizing and verifying their findings to filter out false positives. Using distinct models and wiping context between rounds reduces the chance that all of them hallucinate the same nonexistent bug. He then has the agent fix the critical and high issues, repeats the review loop until none remain, weighs whether the minor issues are worth addressing, and throws out the entire pull request if the process exposes a fundamental architectural flaw.&lt;/p&gt;
&lt;p&gt;Interestingly, his overall delivery speed hasn&amp;rsquo;t increased at all: the review process routinely uncovers pre-existing bugs in surrounding code, turning every new feature into a side quest of writing tests and cleaning up legacy debt. For anyone letting agents open hundred-line pull requests they don&amp;rsquo;t fully grasp, Lawson advises slowing down: ask the agent how the code works and where it could break, have it generate documentation with Mermaid diagrams, or use Matt Pocock&amp;rsquo;s &lt;code&gt;/grill-me&lt;/code&gt; skill until you understand every detail. This approach burns more tokens, but pays off in a deep understanding of failure modes and a much healthier codebase.&lt;/p&gt;
&lt;h2 id="how-cockroachdb-built-vector-indexing-at-scale"&gt;&lt;a href="https://blog.bytebytego.com/p/how-cockroachdb-built-vector-indexing" rel="noopener noreferrer"&gt;How CockroachDB Built Vector Indexing at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo breaks down C-SPANN, the vector indexing algorithm CockroachDB designed in-house because no off-the-shelf approach fit a distributed transactional database. Vectors have no natural total ordering, rendering B-trees useless, so every vector index trades exactness for speed via approximate nearest neighbor (ANN) search. CockroachDB set six hard constraints: no central coordinator node, no reliance on massive in-memory structures, minimal network hops, shardable across nodes, no hot spots, and real-time incremental updates — ruling out both traditional HNSW and IVF. C-SPANN instead uses a wide, shallow hierarchical K-means tree: with a branching factor around 100, a million vectors need just three levels and ten billion vectors need five.&lt;/p&gt;
&lt;p&gt;The key architectural decision is storing each partition as ordinary key-value rows inside CockroachDB, allowing the index to automatically inherit range splitting, load balancing, replication, and multi-region placement without a separate infrastructure stack. To cut storage overhead, RaBitQ compresses 1,536-dimensional vectors from ~3 KB down to 200 bytes (a 94% reduction), then uses the full-precision vectors to rerank a small candidate set. For multi-tenancy, prefix columns like &lt;code&gt;(user_id, embedding)&lt;/code&gt; create isolated per-tenant trees, combining with &lt;code&gt;REGIONAL BY ROW&lt;/code&gt; to satisfy data-residency rules. The trade-offs are stated plainly: C-SPANN trails dedicated vector databases on raw tail latency and currently only supports Euclidean distance in preview, but it is a great fit for workloads where vectors need to live alongside transactional data.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #106</title><link>https://miti99.com/en/post/2026/05/28/</link><pubDate>Thu, 28 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #106.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-heck-does-gps-work-an-interactive-exploration"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-gps-work" rel="noopener noreferrer"&gt;How The Heck Does GPS Work? (An Interactive Exploration)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shri Khalpada&amp;rsquo;s interactive explainer shows that GPS is fundamentally a machine for turning time into distance. Satellites broadcast radio signals at the speed of light, your phone measures how long the signal took to arrive, and each nanosecond corresponds to roughly 0.3 meters. One satellite tells you that you lie somewhere on a sphere (or circle in 2D), a second narrows it to two intersection points, and a third pins down a single point — a method called trilateration. The catch is the clock: satellites carry atomic clocks, while your phone only has a cheap quartz oscillator, and a drift of just a few microseconds throws your position off by hundreds of meters. That is why a fourth satellite is required: there is only one clock-offset correction that makes all four spheres intersect at a single point, allowing the receiver to solve for both exact position and exact time simultaneously.&lt;/p&gt;
&lt;p&gt;Then comes the &amp;ldquo;relativity tax&amp;rdquo;: because satellites move so fast, their clocks tick about 7 microseconds slower per day (special relativity), but higher up in weaker gravity they tick about 45 microseconds faster (general relativity). Left uncorrected, positions would drift by roughly 10 km per day, so satellite clocks are engineered to tick slightly slower before launch on the ground. In practice, modern receivers lock onto 8–12 satellites at once across GPS (US), GLONASS (Russia), Galileo (EU), and BeiDou (China) to reduce error; in dense cities, signals bouncing off buildings (multipath error) remain the hardest problem.&lt;/p&gt;
&lt;h2 id="if-ai-writes-your-code-why-use-python"&gt;&lt;a href="https://medium.com/@NMitchem/if-ai-writes-your-code-why-use-python-bf8c4ba1a055" rel="noopener noreferrer"&gt;If AI Writes Your Code, Why Use Python?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Noah Mitchem argues that the decade-long &amp;ldquo;bargain&amp;rdquo; — picking Python or TypeScript for their huge ecosystems, easier hiring, and fast prototyping while accepting 10x to 100x worse performance than Rust, Go, or C++ — has expired, because AI has gotten good at the hard languages. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 all topped 80% on SWE-bench Verified. The strict type systems and tight compiler feedback loops of Rust and Go let agents iteratively self-correct. The proof is already here: Microsoft ported the TypeScript compiler to Go (roughly 10x faster); Nicholas Carlini at Anthropic orchestrated 16 Claude agents to write a 100,000-line C compiler in Rust across nearly 2,000 Claude Code sessions for under $20,000; and Andreas Kling ported Ladybird&amp;rsquo;s JavaScript engine from C++ to Rust in two weeks — roughly 25,000 lines with zero regressions.&lt;/p&gt;
&lt;p&gt;Even the Python ecosystem is increasingly a &amp;ldquo;Rust ecosystem wearing a Python hat&amp;rdquo;: pydantic, polars, tokenizers, and orjson are all written in Rust; OpenAI acquired Astral (uv, ruff), and Anthropic acquired Bun. The unit of open-source contribution is also shifting from patches to full ports: Armin Ronacher used an agent to port MiniJinja from Rust to Go in 10 hours with only 45 minutes of actual human effort. Exceptions remain: Prisma moved back to a TypeScript/WASM core for serverless, PyTorch still commands roughly 85% of deep learning research, and Zig, Haskell, and Gleam lack training data. As the developer&amp;rsquo;s role shifts toward design and review, Python&amp;rsquo;s ease-of-writing advantage fades while the performance advantage of harder languages compounds every day.&lt;/p&gt;
&lt;h2 id="on-rendering-the-sky-sunsets-and-planets"&gt;&lt;a href="https://blog.maximeheckel.com/posts/on-rendering-the-sky-sunsets-and-planets/" rel="noopener noreferrer"&gt;On Rendering the Sky, Sunsets, and Planets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maxime Heckel walks through rendering atmospheric scattering in WebGL shaders from first principles up to near-photorealistic results. The foundation is raymarching: sampling atmospheric density along the view ray, computing transmittance via Beer&amp;rsquo;s Law, and using phase functions to describe scattering direction. Three physical mechanisms are combined: Rayleigh scattering (shorter wavelengths scatter more strongly, which is why the sky is blue), Mie scattering (larger particles like dust and aerosols that create the bright halo around the sun), and ozone absorption (filtering out specific wavelengths and deepening sunset colors).&lt;/p&gt;
&lt;p&gt;After building a flat sky, the author wraps the atmosphere around a spherical planet: reconstructing world-space coordinates from the depth buffer, using ray-sphere intersection to find atmospheric bounds, and handling depth so the atmosphere blends seamlessly with rendered geometry. With the exact same simulation framework, tweaking parameters produces a solar eclipse or a Martian sky. Finally, to hit real-time frame rates, the article implements Sébastien Hillaire&amp;rsquo;s lookup-table (LUT) method: precomputing transmittance, sky-view, and aerial perspective into textures and sampling them instead of running nested raymarching loops every frame. Packed with interactive widgets to tweak sun angle, altitude, Mie scattering, and ozone density, it is well worth reading directly.&lt;/p&gt;
&lt;h2 id="starting-systems-programming-pt-1-programmers-write-programs"&gt;&lt;a href="https://eblog.fly.dev/startingsystems1.html" rel="noopener noreferrer"&gt;Starting Systems Programming, Pt 1: Programmers Write Programs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the opening installment of Efron Amber Licht&amp;rsquo;s series on systems programming, built around a simple premise: to get good, you have to do the thing, and programmers write programs. In the author&amp;rsquo;s view, a problem counts as &amp;ldquo;systems&amp;rdquo; programming when it interacts with the OS or hardware, operates under tight performance constraints, or manipulates bytes and registers directly. A systems programmer views the computer as a physical machine that can be understood completely rather than an opaque abstraction, and isn&amp;rsquo;t afraid to take things apart to see how they work.&lt;/p&gt;
&lt;p&gt;The article opens the &amp;ldquo;black box&amp;rdquo; of a program by compiling a Go &amp;ldquo;hello world&amp;rdquo; binary and inspecting the executable directly. Readers build small tools from scratch along the way: &lt;code&gt;findoffset&lt;/code&gt; to locate a string inside a file, &lt;code&gt;echo&lt;/code&gt; and &lt;code&gt;cat&lt;/code&gt; to write and print files, &lt;code&gt;binpatch&lt;/code&gt; to patch binary contents directly without recompiling, and hexdump utilities to inspect machine code. Through these exercises, readers see that an executable is just an organized sequence of bytes: the string &lt;code&gt;&amp;quot;hello, world!&amp;quot;&lt;/code&gt; sits at a fixed offset, while the ELF header holds the magic number, target architecture, and the entry point where the CPU begins execution, with values stored in little-endian order on x86-64. The ethos the author wants to pass on: build your own tools, look at the raw data with your own eyes, and understand the system rather than hiding behind abstractions — because at the end of the day, it&amp;rsquo;s all just bytes.&lt;/p&gt;
&lt;h2 id="learning-software-architecture"&gt;&lt;a href="https://matklad.github.io/2026/05/12/software-architecture.html" rel="noopener noreferrer"&gt;Learning Software Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Replying to a physicist asking how to learn software architecture, Matklad argues that the skill is best learned by doing. University design courses felt to him like &amp;ldquo;kindergarteners playing firefighters&amp;rdquo;; what actually taught him architecture was unexpectedly becoming the lead of the IntelliJ Rust project. His second observation is Conway&amp;rsquo;s Law: software mirrors the social structure of the organization that builds it. He quotes neugierig: code ultimately matters less than architecture, and architecture matters less than social problems. Poor &amp;ldquo;scientific code,&amp;rdquo; therefore, stems mainly from incentive structures — like pressure to publish a paper in three months — rather than a lack of programming knowledge.&lt;/p&gt;
&lt;p&gt;There are two ways forward: very rarely, you get a chance to redesign a project&amp;rsquo;s incentive structure; most of the time, you have to accept the constraints and adapt the architecture around them. &lt;code&gt;rust-analyzer&lt;/code&gt; is a prime example: its deep, compiler-like core is kept trivial to build with a test suite that runs in seconds so it can attract strong contributors, while its wide surface of IDE features is isolated so that each feature is wrapped in &lt;code&gt;catch_unwind&lt;/code&gt; and operates on an immutable snapshot of data — allowing weekend contributors to submit imperfect code without crashes cascading or corrupting state. While he has no single &amp;ldquo;bible&amp;rdquo; book to recommend, he points readers to Gary Bernhardt&amp;rsquo;s talk &amp;ldquo;Boundaries,&amp;rdquo; Pieter Hintjens&amp;rsquo;s writings, Ted Kaminski&amp;rsquo;s blog, and Jamii&amp;rsquo;s post &amp;ldquo;Reflections on a decade of coding.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="i"&gt;&lt;a href="https://newsletter.weskao.com/p/im-an-introvert-this-is-how-i-get-myself-to-speak-up" rel="noopener noreferrer"&gt;I&amp;rsquo;m an introvert. This is how I get myself to speak up.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao shares her experience as an introvert in the workplace, where meetings naturally favor people who speak first and think out loud. Introverts prefer time to process before responding, putting them at a systematic disadvantage. Rather than waiting until you feel confident — a moment that usually never arrives — she recommends preparing ahead of time and using concrete tactics she relies on herself.&lt;/p&gt;
&lt;p&gt;Before a meeting, decide in advance that you are going to speak so you don&amp;rsquo;t waste energy debating yourself in the moment, and chime in early before prolonged self-doubt lets the opportunity slip away. Keeping a few go-to opening phrases ready, such as &amp;ldquo;That&amp;rsquo;s a great point. My POV on this is…&amp;rdquo;, makes jumping into a fast-moving discussion much easier. Written channels like docs and meeting notes serve as a parallel track for contributing and leave behind durable artifacts. Remote meetings also offer unique advantages for introverts (controlled lighting, framing, and small video tiles reduce pressure), and you can enlist a trusted colleague to give you a gentle prompt to hold yourself accountable.&lt;/p&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer-in-2026"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms-in-2026/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke reflects on how his LLM usage as a staff engineer has evolved over the past year, and the biggest shift is that agents have gotten genuinely good. In 2025 he only used AI for autocomplete, small edits in unfamiliar codebases, or Q&amp;amp;A; today, every code change starts by handing it to an agent (primarily via the GitHub Copilot app, running dozens of sessions a day). He skims the result for about 30 seconds, throws away most attempts because they aren&amp;rsquo;t what he had in mind, and carefully reviews and polishes the ones that survive. For bug reports, he feeds every single one to an agent first because it diagnoses the issue correctly about 80% of the time. Human expertise still matters, though: one bug took until the 14th agent session to crack, after he supplied context from logs and Slack, reproduced the issue himself, and narrowed the search space.&lt;/p&gt;
&lt;p&gt;He offloads a lot of testing and environment setup to agents: having them test their own changes and inspect the logs, write integration tests, and troubleshoot local machine configs. Test code is treated as &amp;ldquo;cheap,&amp;rdquo; whereas he avoids delegating UI work because agents still lack visual sensibility. Conversely, he still writes all his own PR descriptions, ADRs, Slack messages, and blog posts, because LLMs are overly verbose, struggle to surface the core point, and writing things yourself signals to coworkers that a real human is thinking on the other end. In his view, the most important AI skill today is delegating as much as possible to agents without pushing it too far.&lt;/p&gt;
&lt;h2 id="interrogatory-llm"&gt;&lt;a href="https://martinfowler.com/bliki/InterrogatoryLLM.html" rel="noopener noreferrer"&gt;Interrogatory LLM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler introduces the &amp;ldquo;Interrogatory LLM&amp;rdquo; pattern: instead of a human writing pages of context up front for a complex task, you ask the LLM to interview you, ask every question it needs answered, and synthesize the conversation into a context report that a subsequent session (potentially running a different model) uses to execute the task. He first spotted this technique on Harper Reed&amp;rsquo;s blog, noting the key trick of forcing the LLM to ask only one question at a time — a constraint Fowler found he had to remind the model of repeatedly when trying it himself.&lt;/p&gt;
&lt;p&gt;The pattern also works in reverse: hand an LLM an existing document, such as a software specification, and have it interview a domain expert to verify whether the spec is still accurate, replacing the tedious document review process that many experts struggle with. You can even combine both directions: one LLM drafts the document through an interview, and other LLMs take it to different experts for cross-examination. More broadly, while Fowler himself treats writing as an integral part of thinking, many people find writing painful; a structured conversation with an LLM can help them turn their tacit knowledge into written documentation.&lt;/p&gt;
&lt;h2 id="i-don"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2026-05-15-i-dont-think-ai-will-make-your-processes-go-faster/" rel="noopener noreferrer"&gt;I don&amp;rsquo;t think AI will make your processes go faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After rereading the classics &lt;em&gt;The Toyota Way&lt;/em&gt; and &lt;em&gt;The Goal&lt;/em&gt;, Frederick Van Brabant argues that AI won&amp;rsquo;t speed up organizational processes the way many expect, because we keep misidentifying the bottleneck. Looking at a project timeline, software development takes the longest chunk of time, so the knee-jerk reaction is to add headcount or assume AI will speed it up. But taking a long time doesn&amp;rsquo;t mean the problem originates there: nobody makes a project faster by typing faster. Most of that time is actually spent deciphering vague, title-only tickets like &amp;ldquo;send an email to the user when the order is completed&amp;rdquo; — what goes in the email, what happens on failure, and what counts as completed?&lt;/p&gt;
&lt;p&gt;AI generates code fast, but that doesn&amp;rsquo;t mean it generates the &lt;em&gt;right&lt;/em&gt; code. Comparisons between humans and AI routinely ignore the hand-holding required: to get AI to build the right thing, product and domain experts have to specify every feature and edge case down to the tiniest detail, ballooning the specification phase. Yet that level of clarity is what developers have wanted all along; if human engineers received specs that detailed, their productivity would skyrocket too. If you want faster processes, make sure the people doing the work have what they need to succeed — echoing &lt;em&gt;The Goal&lt;/em&gt;&amp;rsquo;s lesson that a bottleneck must be fed high-quality, predictable inputs.&lt;/p&gt;
&lt;h2 id="using-an-engineering-notebook"&gt;&lt;a href="https://ntietz.com/blog/using-an-engineering-notebook/" rel="noopener noreferrer"&gt;Using an Engineering Notebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicole Tietz shares what she considers perhaps her single most important productivity habit: handwriting in an engineering notebook, a practice borrowed from laboratory notebooks. The notebook records in rich detail what she is doing and why, thoroughly enough that someone else could reproduce the work; every entry is dated, written contemporaneously as the work happens, append-only without erasures or edits, and serves as the primary record rather than a neat copy transcribed from elsewhere. That level of detail matters because your future self is also &amp;ldquo;someone else&amp;rdquo; and will forget most of the context. She started the habit in 2016 while consulting for multiple clients at once, and now uses an e-ink tablet instead of paper notebooks because she is left-handed and doesn&amp;rsquo;t want to carry multiple physical notebooks around.&lt;/p&gt;
&lt;p&gt;The notebook delivers two main benefits. First, it acts as a memory aid: both as a log she can read back to recover context after an interruption, and because the physical act of handwriting improves retention. Second, it is a thinking tool: she routinely writes out a description of a planned code change in her notebook before touching the keyboard, forcing herself to think carefully and spot gaps in her understanding before writing a single line of code. She rarely rereads old notebooks and never shows them to anyone, because &amp;ldquo;the writing &lt;em&gt;is&lt;/em&gt; the work.&amp;rdquo; Her advice: if you haven&amp;rsquo;t tried keeping one, give it a shot and adapt the format, medium, and level of detail to fit your own style.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Documents:&lt;/strong&gt;
&lt;a href="https://static1.squarespace.com/static/50363cf324ac8e905e7df861/t/6a0af5d0484fbf5fe9a7743e/1779103184855/2026-Spring-AI.pdf" rel="noopener noreferrer"&gt;AI eats the world&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #103</title><link>https://miti99.com/en/post/2026/05/23/</link><pubDate>Sat, 23 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #103.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="drunk-post-things-i"&gt;&lt;a href="https://luminousmen.substack.com/p/drunk-post-things-ive-learned-as" rel="noopener noreferrer"&gt;Drunk Post: Things I&amp;rsquo;ve Learned as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post preserves a famous r/ExperiencedDevs thread where a data engineer with 10 years of experience got &amp;ldquo;a little tipsy&amp;rdquo; and wrote down every career lesson he had learned. The original account has since been deleted, but its rare candor keeps the post widely shared. On career growth, the author argues that switching companies is the most effective way to get promoted, job titles matter less than what you actually accomplish, and the closer you are to the product and revenue, the more valued you are — regardless of how technically complex your work is.&lt;/p&gt;
&lt;p&gt;On the technical side, every domain has only about 10–20 core principles, and the fundamentals change very slowly even as tools churn constantly. Good code is code a junior engineer can read and understand, and the best code is code you never had to write at all. Writing documentation is the most underrated skill, right alongside writing proposals for change. For newcomers, SQL is the highest-ROI language; testing is essential, but TDD is overly worshiped. Good engineers know best practices, while senior engineers know when to break them. What the author is proudest of is not any grand system he built, but helping others do better work. The archivist agrees with nearly all of it, except for the author&amp;rsquo;s preference for dynamic languages.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-to-code"&gt;&lt;a href="https://www.chrismdp.com/coding-with-ai-april-2026/" rel="noopener noreferrer"&gt;How I Use AI to Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Parsons argues that if you are still tethered to an IDE like Cursor or Copilot, you are a year behind: the best tools have left the editor for the command line, and he recommends Claude Code or Codex CLI. Programming is AI&amp;rsquo;s &amp;ldquo;home turf&amp;rdquo; because code can be executed and verified immediately. He distinguishes &amp;ldquo;vibe coding&amp;rdquo; (never checking the output) from &amp;ldquo;agentic engineering&amp;rdquo; (deliberately deciding which changes require human inspection and which can be entrusted to tests and automated checks). His core message: senior engineers should train AI to write better code rather than manually reviewing every single diff, because the harness surrounding the model matters more than the prompt.&lt;/p&gt;
&lt;p&gt;A good harness consists of persistent instructions in CLAUDE.md or AGENTS.md, skill files that both enforce rules and load extra context on demand, a verification loop so the agent can check its own work, and a feedback loop that feeds lessons back into those three components — with all knowledge stored in a dedicated markdown repository. The author also walks back his earlier advice to specify the entire solution up front, calling that waterfall in disguise: specify the problem, not the solution. Output quality hinges on context volume — too little yields generic results, while too much drowns the model in noise. Once code generation is no longer the bottleneck, verification becomes the new bottleneck, giving teams with strong automated testing and CI/CD foundations a massive advantage.&lt;/p&gt;
&lt;h2 id="email-is-crazy"&gt;&lt;a href="https://samkhawase.com/blog/email-is-crazy/" rel="noopener noreferrer"&gt;Email is crazy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Email is one of the most successful communication technologies in history, yet underneath it lies a patchwork system governed by more than 100 RFCs. Sam Khawase traces the journey of a single message from Alice to Bob: the mail client merely &amp;ldquo;submits&amp;rdquo; the message to a server, the relay server looks up DNS MX records to find the recipient&amp;rsquo;s mail server, and email is fundamentally a store-and-forward queueing system that retries for days rather than a real-time channel. SMTP was born in an era of trust-based academic networks, so the envelope address (&lt;code&gt;MAIL FROM&lt;/code&gt;) and the user-visible &lt;code&gt;From&lt;/code&gt; header are allowed to differ — the root vulnerability that makes phishing and spam possible.&lt;/p&gt;
&lt;p&gt;Instead of replacing SMTP, the industry bolted on three authentication layers: SPF (a list of authorized sending IPs, which breaks when mail is forwarded), DKIM (a cryptographic signature whose public key lives in DNS), and DMARC (requiring the domain in the &lt;code&gt;From&lt;/code&gt; header to align with the domain validated by SPF or DKIM, paired with a policy of none, quarantine, or reject). Messages then pass through each provider&amp;rsquo;s proprietary filtering stack: IP reputation, domain reputation, content analysis, virus scanning, and link checking. Encryption is usually just &amp;ldquo;Opportunistic TLS&amp;rdquo;: if the receiving server doesn&amp;rsquo;t support &lt;code&gt;STARTTLS&lt;/code&gt;, the connection falls back to plaintext (though policies like MTA-STS can enforce TLS), and TLS only encrypts the transport hop rather than end-to-end. Worst of all, an email can be silently dropped into a spam folder without notifying anyone — completely legal under RFC 5321. Even so, email reliably delivers billions of messages every single day.&lt;/p&gt;
&lt;h2 id="high-performance-git"&gt;&lt;a href="https://gitperf.com/" rel="noopener noreferrer"&gt;High Performance Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;High Performance Git&lt;/em&gt; is a book by Ted Nyman about Git&amp;rsquo;s internal architecture and how to operate massive repositories. Rather than teaching a handful of everyday commands, the book views Git as a stack of layers — a content-addressable database, a filesystem cache, a graph walker, and a wire transfer protocol — and analyzes the performance cost of each layer.&lt;/p&gt;
&lt;p&gt;The chapters progress from objects, refs, the index, and history traversal to packfiles, repository maintenance, sparse checkout, partial clone, transfer protocols, operating at scale, troubleshooting, configuration, and data recovery. The book is aimed at anyone who needs Git to stay fast as codebases, histories, and teams grow: build and CI engineers, monorepo maintainers, and developer productivity teams. The entire book is released for free as a PDF under a Creative Commons Attribution-ShareAlike 4.0 license.&lt;/p&gt;
&lt;h2 id="you-can-beat-the-binary-search"&gt;&lt;a href="https://lemire.me/blog/2026/04/27/you-can-beat-the-binary-search/" rel="noopener noreferrer"&gt;You can beat the binary search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire looks for ways to speed up checking whether a value exists in a sorted array of 16-bit integers — a common operation in Roaring Bitmaps, which currently use binary search. He builds on two observations: modern CPUs (both 64-bit ARM and x64) have SIMD instructions that compare eight 16-bit integers at once, and they have substantial memory-level parallelism, so splitting the array into four parts instead of two can be more effective. This leads to the SIMD Quad algorithm: divide the array into blocks of 16 elements, use a quaternary search on the last element of each block to narrow down the candidate block, and then use SIMD to check all 16 elements in that block simultaneously.&lt;/p&gt;
&lt;p&gt;Benchmarks on Apple M4 and Intel Emerald Rapids show SIMD Quad beating binary search across the article&amp;rsquo;s tests: on Intel it is more than 2x faster when the cache is &amp;ldquo;hot,&amp;rdquo; while on Apple it is more than 2x faster when the cache is &amp;ldquo;cold.&amp;rdquo; The &amp;ldquo;quad&amp;rdquo; step makes almost no difference on Apple, but helps significantly on Intel with large arrays and cold caches. The takeaway: classic algorithms weren&amp;rsquo;t designed for hardware with as much parallelism as today&amp;rsquo;s CPUs, leaving plenty of room for performance gains.&lt;/p&gt;
&lt;h2 id="how-might-a-browser-be-developed"&gt;&lt;a href="https://aifoc.us/how-might-a-browser-be-developed/" rel="noopener noreferrer"&gt;How might a browser be developed?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Kinlan asks: how will browsers be developed in the age of AI? Drawing from experiments building browsers with AI and ultra-fast inference chips, he observes that a comprehensive specification paired with an extensive unit test suite acts as an effective guardrail to keep models on track. In the near term, standards bodies could build a &amp;ldquo;reference browser&amp;rdquo; to uncover gaps in specifications and test suites, while browser vendors use AI to implement features from those battle-tested specs. The focus would then shift to writing great specifications, and browsers would differentiate themselves by their vision for the web rather than raw engineering headcount or budget.&lt;/p&gt;
&lt;p&gt;His longer-term vision ventures into sci-fi territory: a browser that synthesizes feature implementations on the fly at runtime from markup, or even purely from expressed intent. For instance, instead of waiting on WebBluetooth support, the browser could generate the code to talk to a heart-rate monitor directly from available hardware documentation. That could eliminate polyfills and make accessibility and localization happen by default, but it also threatens the web&amp;rsquo;s core promise: that the same URL delivers roughly the same experience to everyone, since the experience would now depend on each user&amp;rsquo;s device and local model. Kinlan urges the industry to start thinking seriously about this trajectory now.&lt;/p&gt;
&lt;h2 id="agentic-coding-is-a-trap"&gt;&lt;a href="https://larsfaye.com/articles/agentic-coding-is-a-trap" rel="noopener noreferrer"&gt;Agentic Coding is a Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lars Faye warns against the trend of &amp;ldquo;agentic coding,&amp;rdquo; where AI writes all the code while humans merely plan and orchestrate. The core issue is the &amp;ldquo;supervision paradox,&amp;rdquo; which Anthropic itself has acknowledged: using AI effectively requires supervising it, yet supervision demands the exact programming skills that atrophy when you overuse AI. Another Anthropic study recorded a 47% drop in debugging proficiency. Unlike past transitions such as moving from assembly to FORTRAN, the skill erosion this time is already visible even among veteran engineers, while junior engineers lose the struggle with code that serves as their most important learning mechanism.&lt;/p&gt;
&lt;p&gt;The author argues that AI is accelerating the wrong part of the job: we don&amp;rsquo;t actually need to write code faster, especially code we don&amp;rsquo;t understand, and for many developers, writing code &lt;em&gt;is&lt;/em&gt; how they think and plan. There is also vendor lock-in risk — when Claude goes down, many teams grind to a halt — and unpredictable token costs, whereas human salaries are fixed. His prescription is to demote AI back to an assistant role: use AI for specs and planning, but write 20% to 100% of the code yourself depending on the task, never generate more code than you can review in a single sitting, and never ask AI to do something you haven&amp;rsquo;t done or couldn&amp;rsquo;t do yourself.&lt;/p&gt;
&lt;h2 id="be-the-idiot"&gt;&lt;a href="https://luminousmen.substack.com/p/be-the-idiot" rel="noopener noreferrer"&gt;Be the Idiot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;luminousmen argues that most engineering failures happen because someone was afraid of looking stupid, making clarifying questions not a weakness but a core professional skill. Drawing inspiration from military radio protocols — where the receiver always reads back an order to confirm, not out of incompetence, but because being understood matters more than sounding smart — the author applies two principles to software engineering: repeat critical information across multiple channels such as types, docstrings, and explicit parameter names; and choose unambiguous wording, like &lt;code&gt;timeout_seconds: 30&lt;/code&gt; instead of &lt;code&gt;timeout: short&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author shares four &amp;ldquo;dumb&amp;rdquo; questions that have saved him time and again: what happens when this fails, how do we know it&amp;rsquo;s working properly, what does &amp;ldquo;done&amp;rdquo; look like, and can you show me an example? Phrasing matters too: instead of asking &amp;ldquo;Why are we doing this stupid thing?&amp;rdquo;, ask &amp;ldquo;Is there a specific reason we&amp;rsquo;re using X here?&amp;rdquo; — assuming you&amp;rsquo;re missing context rather than assuming the other person is wrong. About 80% of the time he really was missing context, and the other 20% of the time the question sparked a valuable discussion. After all, the only thing more expensive than looking dumb in a meeting is building the wrong thing because nobody dared to ask.&lt;/p&gt;
&lt;h2 id="3-constraints-before-i-build-anything"&gt;&lt;a href="https://jordanlord.co.uk/blog/3-constraints/" rel="noopener noreferrer"&gt;3 constraints before I build anything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jordan Lord shares three constraints he applies before building any product, distilled from 10 years of product work and multiple failures caused by overcomplication or lack of identity. To him, constraints are a catalyst for creativity because they narrow the option space. The first constraint is &amp;ldquo;one page or nothing&amp;rdquo;: every idea must fit onto a single-page brief that serves as a north star when talking to investors, teammates, or family. If you can&amp;rsquo;t fill one page, the idea isn&amp;rsquo;t ready; if you need more than one page, it&amp;rsquo;s too complicated.&lt;/p&gt;
&lt;p&gt;The second constraint: the core technology must be separable from the product. That could be a method, tool, or library that powers the current product but survives if the product pivots — much like Git was created to support Linux kernel development, or Kubernetes at Google. Products pivot, while core technology compounds in value over time. The third constraint: a defining constraint must shape the product and remain immediately visible to the user, like Minecraft being built entirely out of blocks or IKEA&amp;rsquo;s flat-pack self-assembly furniture. It wards off feature creep and creates unmistakable identity. Any idea that fails to pass all three constraints doesn&amp;rsquo;t get built.&lt;/p&gt;
&lt;h2 id="swissing-a-table"&gt;&lt;a href="https://philpearl.github.io/post/swissing_a_table/" rel="noopener noreferrer"&gt;Swissing a Table&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Pearl explores the Swiss table — the hash table design behind Go&amp;rsquo;s new map implementation — by evolving a simple open-addressed hash table step by step. First, he replaces linear probing with a quadratic-style probing sequence like Go&amp;rsquo;s; next, he groups 8 key–value pairs into a bucket; then he adds 8 control bytes per group (the highest bit marks an empty slot, while the lower 7 bits store a hash fragment); and finally he uses bitwise SWAR tricks on a 64-bit integer to match all 8 control bytes simultaneously instead of checking slots one by one.&lt;/p&gt;
&lt;p&gt;Insertion benchmarks show that a Swiss table doesn&amp;rsquo;t always win: when the table is sparse (around 10–4,000 elements), it is 19–36% slower than the simple table, only pulling ahead as the table fills up and cutting insertion time by up to 71.65% when completely full (32,768 elements). According to the author, the biggest win is that the table can run at high load factors with very little performance degradation — making it primarily a memory-saving optimization rather than a raw speed boost. Go&amp;rsquo;s map currently uses SIMD on amd64 (Intel) but not yet on ARM, so the author saves the SIMD exploration for a follow-up post.&lt;/p&gt;
&lt;h2 id="the-ai-engineering-stack-we-built-internally--on-the-platform-we-ship"&gt;&lt;a href="https://blog.cloudflare.com/internal-ai-engineering-stack/" rel="noopener noreferrer"&gt;The AI engineering stack we built internally — on the platform we ship&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares the internal AI infrastructure they built over 11 months, running entirely on the same products they sell to customers. Over a 30-day window, 3,683 internal users (93% of R&amp;amp;D) used AI coding tools, driving over 20 million requests through AI Gateway and 241 billion tokens; in some weeks, merge request volume nearly doubled the previous quarter&amp;rsquo;s baseline. The architecture spans three layers. The foundation layer uses Cloudflare Access for zero-trust authentication, AI Gateway for routing, cost tracking, and data retention controls, and Workers AI to serve open-weight models at a fraction of proprietary model costs. A single login command configures everything, and routing traffic through an intermediate Worker from day one let them roll out new features later without touching user-side configs.&lt;/p&gt;
&lt;p&gt;The knowledge layer uses Backstage as a service catalog and automatically generates &lt;code&gt;AGENTS.md&lt;/code&gt; files across roughly 3,900 repositories, describing structure, conventions, and boundaries so agents don&amp;rsquo;t have to guess. The execution layer runs an AI Code Reviewer on every merge request: it classifies risk level, dispatches specialized agents, organizes findings by category and severity, and cites specific rules from the Engineering Codex — Cloudflare&amp;rsquo;s internal engineering standards packaged as agent skills. According to Cloudflare, none of the individual pieces are novel; the differentiator is how they are wired together.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7jIm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5632abfa-88b9-4f40-8feb-13b4a7c6e1ce_2484x3002.png" alt="MCP vs Skills, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gUOK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F32f62036-5c89-4686-941e-57d84297de42_2484x3002.png" alt="5 Way to Defend Prompt Injection"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #100</title><link>https://miti99.com/en/post/2026/05/03/</link><pubDate>Sun, 03 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/03/</guid><description>&lt;p&gt;&lt;em&gt;Well, it&amp;rsquo;s been a long time since I wrote a Newsletter entirely by myself. My writing skills have probably gotten rusty. But to mark the milestone of Newsletter #100, I&amp;rsquo;ll try to write a bit on my own. This post won&amp;rsquo;t have any &lt;code&gt;AI-Assisted&lt;/code&gt; tag, and I&amp;rsquo;ll focus on articles that are already in Vietnamese. I&amp;rsquo;ll also mainly share my personal experiences rather than summarizing like the AI does. Hopefully it won&amp;rsquo;t disappoint you — just think of it as a nice change of pace!^^&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&amp;ldquo;Enjoy Newsletter #100&amp;rdquo;!^^&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="bên-trong-moonshot-kimi"&gt;&lt;a href="https://dentmakers.substack.com/p/ben-trong-moonshot-kimi" rel="noopener noreferrer"&gt;Bên trong Moonshot (Kimi)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is a translation of an original Chinese article about the author&amp;rsquo;s interviews with employees inside Moonshot (the company behind Kimi). Honestly, reading it left me deeply admiring and drawn to the work culture described (though of course it might not match reality 100% — I can&amp;rsquo;t be sure, since articles often paint a rosier picture than real life). I really love the model of a company built as a gathering of geniuses, letting them &amp;ldquo;swim on their own,&amp;rdquo; make their own decisions, and build everything themselves — no bosses, no KPIs, etc. Even though I don&amp;rsquo;t know how effective this model is in practice, or how it holds up under commercial pressure from investors, I genuinely love that spirit of striving for improvement and pouring oneself tirelessly into the work out of pure passion (perhaps because I&amp;rsquo;m no longer that passionate about my current job). Still, I know Moonshot wouldn&amp;rsquo;t be for me, since I&amp;rsquo;m no genius, I don&amp;rsquo;t speak Chinese, and honestly my passion for the industry in general and my company in particular just isn&amp;rsquo;t what it used to be back in my sophomore and junior years of college (the part I loved most was coding, and AI has taken that over :v while the remaining parts — planning, code review, sending to QC, deploying, etc. — all have to be done manually or reviewed. Reviewing code I didn&amp;rsquo;t write myself is genuinely such a headache).&lt;/p&gt;
&lt;p&gt;That&amp;rsquo;s just me venting a bit — I still have huge respect for my current company and bosses. Back when I was a wide-eyed intern, I found a company that gave me what felt like a very generous offer at the time, and it also gave me the opportunity to fulfill many of my dreams. Compared to many of my peers, I can consider myself pretty accomplished. And the company truly &amp;ldquo;survived&amp;rdquo; through tough times like COVID-19 — in fact, it thrived during that period and hit some unbelievable targets. I really should know how to be content :)))&lt;/p&gt;
&lt;h2 id="goclaw-30---một-bước-ngoặt-lớn"&gt;&lt;a href="https://goonnguyen.substack.com/p/goclaw-30-mot-buoc-ngoat-lon" rel="noopener noreferrer"&gt;GoClaw 3.0 - Một bước ngoặt lớn!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Duy /Zuey/ (Mr.Goonie) is someone I follow closely, and thanks to him I&amp;rsquo;ve been exposed to a lot of perspectives and stayed up to date with news in tech in general and AI in particular. He&amp;rsquo;s the founder and creator of several companies and projects. Among them, I bought &lt;a href="https://claudekit.cc/" rel="noopener noreferrer"&gt;ClaudeKit&lt;/a&gt; to support him and have been really happy with it. It has helped me a ton in my daily work as well as in experimenting with Claude Code.&lt;/p&gt;
&lt;p&gt;Quick 30-second plug: you can use my referral link &lt;a href="https://claudekit.cc/?ref=BWA910UK" rel="noopener noreferrer"&gt;here&lt;/a&gt; to buy ClaudeKit and give it a try. Duy very generously offers a 14-day no-questions-asked refund.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://goclaw.sh/" rel="noopener noreferrer"&gt;GoClaw&lt;/a&gt; is another product he&amp;rsquo;s involved with. With the launch of GoClaw v3.0, he wrote this post to clarify that GoClaw is not a fork of OpenClaw, but rather inspired by it and implemented from scratch by the team. I&amp;rsquo;ve tried GoClaw since earlier versions, around v2. Personally, I find GoClaw quite user-friendly and easier to use than OpenClaw. The trade-off, however, is that it isn&amp;rsquo;t compatible with and is harder to extend using OpenClaw&amp;rsquo;s skill ecosystem like ClawHub. That said, GoClaw has one feature I find truly groundbreaking: Agent Team. Agents have their own distinct &amp;ldquo;souls&amp;rdquo; and instructions, and they can interact with each other inside a team. GoClaw also makes it very easy to trace issues and see exactly what an agent is doing. As a backend dev, that&amp;rsquo;s where GoClaw really wins me over. If I had to name a downside, GoClaw manages permissions quite strictly, which can be a bit annoying when you ask it to do something and it can&amp;rsquo;t — especially when working with files in workspaces. I&amp;rsquo;m not sure whether that&amp;rsquo;s due to breaking changes between versions or if it was designed that way from the start. Check out the article for more details and install GoClaw to try it out yourself.&lt;/p&gt;
&lt;h2 id="claude-opus-47---phân-tích-hành-vi-sau-3-ngày-sử-dụng"&gt;&lt;a href="https://goonnguyen.substack.com/p/claude-opus-47-phan-tich-hanh-vi" rel="noopener noreferrer"&gt;Claude Opus 4.7 - Phân tích hành vi sau 3 ngày sử dụng&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Another post from Duy, sharing his observations on Claude Opus 4.7 after three days of use. Sorry, I honestly don&amp;rsquo;t know what else to write for this one :(((&lt;/p&gt;
&lt;h2 id="ai--các-nghề-mới-trong-kỷ-nguyên-agents"&gt;&lt;a href="https://goonnguyen.substack.com/p/ai-and-cac-nghe-moi-trong-ky-nguyen" rel="noopener noreferrer"&gt;AI &amp;amp; Các nghề mới trong Kỷ Nguyên Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yep, it&amp;rsquo;s Zuey again, mostly because I haven&amp;rsquo;t followed enough other Vietnamese writers yet to recommend more variety :v. In this post he talks about emerging career paths we&amp;rsquo;ll likely need in the near future as AI continues to boom. It&amp;rsquo;s a great read for junior devs and recent or upcoming grads who feel lost about job opportunities and career direction.&lt;/p&gt;
&lt;h2 id="hướng-dẫn-xây-dựng-second-brain-hiệu-quả-với-ai-bắt-đầu-từ-đâu-cho-đúng"&gt;&lt;a href="https://goonnguyen.substack.com/p/huong-dan-xay-dung-second-brain-hieu" rel="noopener noreferrer"&gt;Hướng dẫn xây dựng Second Brain hiệu quả với AI: bắt đầu từ đâu cho đúng?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Duy again. In this article he discusses a term that has been trending lately — &lt;em&gt;&amp;ldquo;Second Brain&amp;rdquo;&lt;/em&gt;. His take is that alongside having a 2nd brain, your 1st brain is still critically important. Check out the post for the full details.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;It&amp;rsquo;s probably been way too long since I wrote a post myself or reviewed one properly (at least since I subscribed to Claude), so my writing skills have definitely regressed — I only managed to write properly for the first post or two :v. Plus I didn&amp;rsquo;t have a diverse enough set of Vietnamese sources for this issue, so it looks a bit dry. Still, one way or another, we&amp;rsquo;ve made it to the milestone of Newsletter #100. Hope to have your continued support in the future. Cheers!&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #95</title><link>https://miti99.com/en/post/2026/04/14/</link><pubDate>Tue, 14 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #95.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="12-claude-code-features-every-engineer-should-know-subagents-claudemd-checkpoints-mcp-and-more"&gt;&lt;a href="https://www.youtube.com/watch?v=E4fzxVMOav4" rel="noopener noreferrer"&gt;12 Claude Code Features Every Engineer Should Know: Subagents, CLAUDE.md, Checkpoints, MCP, and more&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteAI video walks through 12 features every engineer should know when working with Claude Code, Anthropic&amp;rsquo;s terminal-native coding agent. At the top of the list are Subagents, which break a complex task into smaller pieces handled in parallel by isolated worker agents—speeding up execution while keeping the main session&amp;rsquo;s context window clean. Meanwhile, &lt;code&gt;CLAUDE.md&lt;/code&gt; serves as the project&amp;rsquo;s onboarding manual, recording architecture, coding conventions, and team-specific rules so Claude has the right context from the very first prompt.&lt;/p&gt;
&lt;p&gt;Checkpoints snapshot workspace state as you go, letting you rewind cleanly whenever the AI heads down the wrong path instead of untangling changes by hand. MCP (Model Context Protocol) integration extends Claude Code by connecting it directly to external services like databases, APIs, and developer tools. The walkthrough is a solid overview both for newcomers and for regular Claude Code users looking to get more mileage out of the tool.&lt;/p&gt;
&lt;h2 id="quantization-from-the-ground-up"&gt;&lt;a href="https://ngrok.com/blog/quantization" rel="noopener noreferrer"&gt;Quantization from the ground up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Rose (ngrok) explains model quantization from first principles—showing how large language models can be compressed to roughly a quarter of their size and run twice as fast while losing only about 5–10% accuracy. He starts with why LLMs are so huge in the first place: an 80-billion-parameter model like &lt;code&gt;Qwen3-Coder-Next&lt;/code&gt; takes around 159 GB of memory because each parameter is stored as a multi-byte floating-point number. Fortunately, parameter weights cluster tightly around zero, meaning we can represent them with far fewer bits without losing much information.&lt;/p&gt;
&lt;p&gt;The post compares two quantization schemes: &lt;em&gt;symmetric&lt;/em&gt; quantization is simple but wastes dynamic range when weights are skewed, whereas &lt;em&gt;asymmetric&lt;/em&gt; quantization adds a zero-point offset and cuts average quantization error from roughly 18% down to 8.5%. In practice, weights are quantized in blocks of 32–256 values so a single outlier only skews its local block rather than distorting the entire model. Measuring post-quantization quality via perplexity, KL divergence, and the GPQA Diamond benchmark shows that 8-bit quantization is nearly lossless, 4-bit loses roughly 5–10%, and 2-bit degrades sharply. In return, inference speed on an M1 Max jumps from 19.45 to 43.32 tokens/sec at 4-bit.&lt;/p&gt;
&lt;h2 id="jpeg-compression"&gt;&lt;a href="https://www.sophielwang.com/blog/jpeg" rel="noopener noreferrer"&gt;JPEG compression&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With rich interactive visualizations, Sophie Wang explains how JPEG compression exploits two things: quirks of the human visual system and the natural smoothness of real-world photographs. Because human eyes are far more sensitive to brightness (luminance) than to color detail (chrominance), JPEG first converts an image from RGB to YCbCr to separate the two. It then performs &lt;em&gt;chroma subsampling&lt;/em&gt;—sharing color values across neighboring pixels—producing an image that looks nearly indistinguishable from the original.&lt;/p&gt;
&lt;p&gt;Next, each 8×8 block of pixels undergoes a Discrete Cosine Transform (DCT), expressing the block as a weighted sum of cosine waves. DCT alone doesn&amp;rsquo;t shrink the data, but it concentrates most of the visual signal into a handful of low-frequency coefficients while leaving high-frequency coefficients near zero. The quantization step divides each coefficient by a quantization table entry and rounds to the nearest integer, turning most high-frequency coefficients—fine details the eye barely notices—into zeros. Finally, the coefficients are scanned in a zigzag order to group long runs of zeros together and entropy-coded into a compact file; decompression simply runs the pipeline in reverse.&lt;/p&gt;
&lt;h2 id="what-81000-people-want-from-ai"&gt;&lt;a href="https://www.anthropic.com/features/81k-interviews" rel="noopener noreferrer"&gt;What 81,000 people want from AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic published the largest multilingual qualitative study of AI users to date: using a custom Claude interviewer, they conducted open-ended conversations with 80,508 opt-in Claude users across 159 countries and 70 languages about their hopes and fears for AI. The overarching message is that people want AI to help them live better lives, not just work faster. Top aspirations include professional excellence (19%), personal growth and transformation (14%), life management (14%), and reclaiming free time (11%). Beneath surface-level productivity requests usually sits a deeper human goal—automating email is really about having more time with family.&lt;/p&gt;
&lt;p&gt;Fully 81% of participants said AI had already helped them move closer to their goals, mainly through productivity gains (32%), acting as a thought partner (17%), and learning (10%). At the same time, respondents voiced an average of 2.3 concerns each: unreliability and hallucinations (27%), job displacement (22%), loss of human agency (22%), cognitive atrophy (16%), and lack of governance (15%). Benefits and anxieties often go hand in hand within the same person: users who value AI for emotional support are three times more likely to worry about unhealthy dependence. Users in lower-income regions expressed more optimism and viewed AI as an economic equalizer, while users in wealthier regions focused more on managing complex, busy lives.&lt;/p&gt;
&lt;h2 id="scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto"&gt;&lt;del&gt;&lt;a href="https://www.semicolonandsons.com/articles/scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto" rel="noopener noreferrer"&gt;Scaling a Monolith to 1M LOC: 113 Pragmatic Lessons from Tech Lead to CTO&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This post distills 113 pragmatic lessons from scaling a monolith to one million lines of code, drawn from the author&amp;rsquo;s journey from Tech Lead to CTO. The central thread is that sound architectural choices matter far more than micro-optimizations: rather than slapping a cache over a slow endpoint, fix the underlying database query or missing index, because a single long-running query can halve the throughput of the entire system. Monitoring and observability should be treated as first-class features, with alerts for latency regressions, N+1 queries, and cache eviction rates, backed by an &amp;ldquo;inbox zero&amp;rdquo; discipline for error tracking where every alert is either fixed or silenced.&lt;/p&gt;
&lt;p&gt;Keeping deployments fast (under two minutes)—by decoupling frontend and backend builds, parallelizing CI steps, and picking fast tooling—dramatically lowers risk because bugs are caught and rolled back quickly. On security, the author recommends starting from concrete threat models like account takeover, spam, or DDoS rather than generic checklists. Finally, the human side matters just as much as the code: avoid blame culture, set clear expectations, and cultivate psychological safety across the team.&lt;/p&gt;
&lt;h2 id="harness-design-for-long-running-application-development"&gt;&lt;a href="https://www.anthropic.com/engineering/harness-design-long-running-apps" rel="noopener noreferrer"&gt;Harness design for long-running application development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic&amp;rsquo;s engineering team tackles two failure modes that plague AI agents on long-running tasks: models lose coherence as the context window fills up, and they consistently grade their own work too generously. Their solution is a GAN-inspired multi-agent harness: a &lt;em&gt;Planner&lt;/em&gt; expands a short user prompt into a detailed product spec, a &lt;em&gt;Generator&lt;/em&gt; builds the application, and a separate &lt;em&gt;Evaluator&lt;/em&gt; grades the running app against explicit criteria and sends critique back. For subjective work like frontend design, the team replaced vague &amp;ldquo;does this look good?&amp;rdquo; prompts with concrete rubrics and let the Generator and Evaluator iterate for 5–15 rounds, sometimes pivoting to a completely new aesthetic direction mid-run.&lt;/p&gt;
&lt;p&gt;In their experiments, starting a fresh session with a structured handoff document worked better than in-place context compaction—especially when models suffered from &amp;ldquo;context anxiety,&amp;rdquo; prematurely wrapping up work because they sensed the context window running out. On a benchmark building a game-maker tool with Opus 4.5, a single solo agent spent $9 and 20 minutes to produce a broken app, whereas the full multi-agent harness spent $200 and 6 hours to deliver a genuinely playable, feature-complete application. Another key lesson: re-evaluate your harness every time the underlying model upgrades, because scaffolding that used to be essential can become dead weight.&lt;/p&gt;
&lt;h2 id="why-i-vibe-in-go-not-rust-or-python"&gt;&lt;a href="https://lifelog.my/episode/why-i-vibe-in-go-not-rust-or-python" rel="noopener noreferrer"&gt;Why I Vibe in Go, Not Rust or Python&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author explains why Go is his language of choice over Rust or Python when coding with AI (&amp;ldquo;vibe coding&amp;rdquo;). Between AI-generated code and production, he argues, you need multiple independent filters—and Go gives you five: the compiler, a static type system, explicit error handling, enforced simplicity, and finally human judgment. Python lacks compile-time verification—type hints are optional—so when an AI generates thousands of lines a day, structural bugs hide until runtime, often in production.&lt;/p&gt;
&lt;p&gt;Rust sits at the other extreme: it gives ironclad correctness guarantees, but the borrow checker and lifetime annotations force the human reviewer to spend mental energy solving language-level puzzles rather than focusing on architecture and domain logic. Go hits the sweet spot between compile-time safety and cognitive simplicity; its backward-compatibility promise means code written in 2024 still compiles cleanly in 2026, and deployment is a single static binary rather than a fragile Python container image.&lt;/p&gt;
&lt;h2 id="the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon"&gt;&lt;a href="https://larstofus.com/2026/03/22/the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon/" rel="noopener noreferrer"&gt;The gold standard of optimization: A look under the hood of RollerCoaster Tycoon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Sawyer wrote &lt;em&gt;RollerCoaster Tycoon&lt;/em&gt; almost entirely in x86 assembly—giving him tighter control over performance than C or C++ compilers of the late 1990s could match—and the game remains a gold standard of software optimization. This deep dive examines the tricks that let it simulate a bustling theme park with thousands of guests on modest 1999 hardware. Instead of defaulting to 32-bit integers everywhere, every struct field was sized to the exact byte width of its maximum expected value—even using different integer widths for different in-game currency totals to pack structs tightly in memory.&lt;/p&gt;
&lt;p&gt;The codebase replaces multiplication and division by powers of two with fast bitshifts, and remarkably, the game&amp;rsquo;s simulation formulas themselves were designed around constants that were powers of two—a level of harmony between game design and low-level systems programming rarely seen today. Algorithmically, park guests don&amp;rsquo;t run expensive A* pathfinding across the whole park; they wander semi-randomly with local heuristics until they stumble onto a ride. The engine also skips guest-to-guest collision detection entirely: thousands of visitors can occupy the same tile, with overcrowding simply penalized in their happiness calculation.&lt;/p&gt;
&lt;h2 id="queueing-requests-queues-your-capacity-problems-too"&gt;&lt;a href="https://pushtoprod.substack.com/p/queueing-requests-queues-your-capacity-problems-too" rel="noopener noreferrer"&gt;Queueing Requests Queues Your Capacity Problems, Too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post points out that putting a queue in front of an overloaded service often hides a capacity problem rather than solving it. If a system capable of processing 1,000 requests per second receives 2,000 requests per second, after one hour the queue holds 3.6 million backlogged requests—meaning users wait roughly 60 minutes for a response even though server-side processing time per request is still a brisk 1 second. The trap is that user-perceived latency equals queue wait time plus processing time, whereas server latency metrics only measure processing time—so your dashboards stay green while customers experience a total outage.&lt;/p&gt;
&lt;p&gt;Queue math is unforgiving: exceeding capacity by just 10% for an hour builds a backlog of 360,000 requests and adds 6 minutes of latency, because the capacity deficit accumulates linearly over time. Swapping queueing disciplines (FIFO, LIFO, priority, weighted fair queueing) only redistributes wait time across requests in a zero-sum game. The only real fix is adding capacity (or shedding load): provisioning 50% extra capacity drains a one-hour crisis backlog in about an hour, whereas 10% extra headroom takes nine hours to recover.&lt;/p&gt;
&lt;h2 id="7-more-common-mistakes-in-architecture-diagrams"&gt;&lt;a href="https://www.ilograph.com/blog/posts/more-common-diagram-mistakes/" rel="noopener noreferrer"&gt;7 More Common Mistakes in Architecture Diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ilograph walks through seven common mistakes that make system architecture diagrams hard to read. First is unlabeled resources—every box should include both its technology type and a descriptive role name, never just a vendor icon. Second is &amp;ldquo;island&amp;rdquo; components floating with no connections, which defeats the purpose of showing relationships. Third is the giant &amp;ldquo;everything diagram&amp;rdquo;; it is much clearer to split complex systems into multiple focused views where each diagram tells one coherent story.&lt;/p&gt;
&lt;p&gt;Mistake four is &amp;ldquo;conveyor-belt syndrome&amp;rdquo;—drawing request flows as a simplistic left-to-right pipeline that hides back-and-forth request/response interactions, which are much better shown with a sequence diagram. Fifth is gratuitous animation that distracts without adding meaning, and sixth is the &amp;ldquo;fan trap,&amp;rdquo; where routing everything through a central hub obscures which upstream nodes actually talk to which downstream nodes. Finally, the author cautions against AI-generated architecture diagrams, which today remain vague, prone to hallucinating connections, and bad at deciding which details to include or omit.&lt;/p&gt;
&lt;h2 id="how-to-do-ai-assisted-engineering"&gt;&lt;a href="https://newsletter.eng-leadership.com/p/how-to-do-ai-assisted-engineering" rel="noopener noreferrer"&gt;How to Do AI-Assisted Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article synthesizes advice from 15 experienced engineers and engineering leaders on how to practice AI-assisted software engineering effectively. The strongest consensus is &lt;em&gt;design first, code second&lt;/em&gt;: when AI handles implementation, the bottleneck shifts upstream to system design, which is where engineers should invest their time. Rather than typing ad-hoc prompts from scratch each time, effective practitioners build structured, repeatable workflows using templates, custom commands, and &lt;code&gt;CLAUDE.md&lt;/code&gt; files that codify project standards and architectural constraints.&lt;/p&gt;
&lt;p&gt;Equally important is separation of concerns in the agent loop: decouple code generation from verification, use specialized review agents to audit diffs for security, performance, and correctness from independent angles, and keep humans firmly in the loop for high-stakes decisions like merging and deploying. An AI&amp;rsquo;s first output should be treated as a rough draft, not a finished product—requiring multiple passes of multi-angle review before it ships.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!YJG0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd3e5a12b-4237-4661-b090-d518a6da7f20_2508x3000.png" alt="Load Balancer vs API Gateway"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LrVm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7a20a0cb-3142-4c32-b772-f002f1a288fd_2880x3862.jpeg" alt="REST vs gRPC"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6SID!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F14a25337-0104-4c6c-b91a-3a2cd6afd6e4_2508x3000.png" alt="Session-Based vs JWT-Based Authentication"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LuLK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa8dd9e12-2979-4040-a138-08723094b8cf_2536x3436.jpeg" alt="A Cheat Sheet on The Most-Used Linux Commands"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #94</title><link>https://miti99.com/en/post/2026/04/02/</link><pubDate>Thu, 02 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #94.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="inside-the-claude-code-source"&gt;&lt;a href="https://gist.github.com/Haseeb-Qureshi/d0dc36844c19d26303ce09b42e7188c1" rel="noopener noreferrer"&gt;Inside the Claude Code source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After the Claude Code CLI source code was inadvertently exposed in late March 2026, Haseeb Qureshi read through its core modules and compared its architecture with OpenAI&amp;rsquo;s Codex CLI. The first surprise is that the terminal UI is actually a React application rendered via Ink, bringing a web mental model to the terminal, whereas Codex&amp;rsquo;s TUI is written entirely in Rust. The entire lifecycle of a request runs through an async generator pipeline: every event flows down a single stream consumed identically by the CLI, SDK, and IDE bridge, which differ only in how they render those events. To survive long coding sessions, Claude Code layers four context-compaction strategies (proactive, reactive, snip, and context collapse), whereas Codex relies on two.&lt;/p&gt;
&lt;p&gt;The system prompt is assembled from roughly 15 functions and split in two by a cache-boundary marker: a static first half (~3,000 tokens of core instructions) cached globally across users, and a dynamic second half holding session-specific context like &lt;code&gt;CLAUDE.md&lt;/code&gt; and MCP instructions. Internal Anthropic engineers even receive different prompt rules than external users—such as a strict 25-word limit between tool calls and an adversarial verification sub-agent. Bun&amp;rsquo;s compile-time feature flags strip dead code from public builds while revealing unreleased internal features like &lt;code&gt;VOICE_MODE&lt;/code&gt; and &lt;code&gt;KAIROS&lt;/code&gt;. The author&amp;rsquo;s takeaway: across ~500,000 lines of TypeScript, actual model API calls take up only a few hundred lines; the underlying model is the easiest part to swap out, while the surrounding &lt;em&gt;harness&lt;/em&gt; encodes years of hard-won operational craft.&lt;/p&gt;
&lt;h2 id="ai-will-accelerate-your-tech-debt"&gt;&lt;del&gt;&lt;a href="https://securosis.com/ai/ai-will-accelerate-your-tech-debt/" rel="noopener noreferrer"&gt;AI Will Accelerate Your Tech Debt&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Chris Farris compares many engineering organizations to families living paycheck to paycheck: after years of prioritizing feature velocity over sustainable architecture, they are one major outage away from bankruptcy, and every minor incident burns the exact hours that should have gone toward paying down technical debt. Pouring AI coding tools into that environment, he argues, is like passing a tax cut on a structural deficit: it feels great and boosts short-term output, but makes the underlying fiscal problem worse. When the cost of generating code drops near zero, the natural economic friction that used to filter out half-baked features vanishes—leaving the same overstretched team with more code, a wider attack surface, and deeper system complexity.&lt;/p&gt;
&lt;p&gt;On the security side, building on Rich Mogull&amp;rsquo;s &amp;ldquo;Core Collapse&amp;rdquo; scenario, the author warns that AI-equipped attackers will discover and exploit vulnerabilities faster than defenders can patch them, and organizations that don&amp;rsquo;t understand their own environments cannot use AI to defend them either. Unlike Mogull, he argues you cannot outsource technical-debt remediation. Instead, he proposes a &amp;ldquo;Technology Troika&amp;rdquo;—bringing Finance/FinOps, Security, and Platform Engineering together to shore up foundations before opening the AI floodgates. That means investing in unglamorous fundamentals like identity management, data classification, and dependency mapping, alongside having the courage to decommission legacy systems outright rather than endlessly refactoring them. Buying more AI tools won&amp;rsquo;t save a rotting foundation.&lt;/p&gt;
&lt;h2 id="how-slack-rebuilt-notifications-"&gt;&lt;a href="https://slack.engineering/how-slack-rebuilt-notifications/" rel="noopener noreferrer"&gt;How Slack Rebuilt Notifications 📣&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s engineering team recounts rebuilding their notification settings from the ground up to reduce notification fatigue. Notifications consistently ranked among the top three drivers of customer support tickets, and the problem wasn&amp;rsquo;t just volume—it was the architecture itself: desktop and mobile had four conflicting mental models, &lt;em&gt;what&lt;/em&gt; you get notified about was tightly coupled to &lt;em&gt;how&lt;/em&gt; it gets delivered, preferences didn&amp;rsquo;t sync cleanly across devices, and advanced overrides were scattered across hidden menus.&lt;/p&gt;
&lt;p&gt;The redesign consolidated everything into a single unified model: every channel now offers three clear choices—&amp;ldquo;All new posts,&amp;rdquo; &amp;ldquo;Mentions only,&amp;rdquo; or &amp;ldquo;Mute&amp;rdquo;—while push delivery is toggled independently per device category (desktop vs. mobile). The hardest part was migrating millions of existing users safely. To preserve backward compatibility and allow instant rollbacks, the team avoided mutating legacy rows in the database and instead translated old preferences on read—for instance, mapping the old &amp;ldquo;Nothing&amp;rdquo; setting to &amp;ldquo;Mentions only&amp;rdquo; with push notifications turned off. They also removed the explicit &amp;ldquo;Save&amp;rdquo; button so changes apply immediately, shared React components across platforms, and rewrote some of Slack&amp;rsquo;s oldest iOS screens. Post-launch, engagement with notification settings jumped 5x and stayed elevated weeks later.&lt;/p&gt;
&lt;h2 id="better-faster-and-even-more"&gt;&lt;a href="https://randsinrepose.com/archives/better-faster-and-even-more/" rel="noopener noreferrer"&gt;Better, Faster, and (Even) More&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) shares the tools and habits he has built over 90 days of working intensively with Claude Code, at a moment when the cost of going from &amp;ldquo;random idea&amp;rdquo; to &amp;ldquo;working software&amp;rdquo; has never been lower. Everything lives under &lt;code&gt;~/Projects/&lt;/code&gt;, with each project in its own Git repository alongside three special repos: &lt;code&gt;dotfiles&lt;/code&gt; for machine configuration symlinked into place, a private &lt;code&gt;credentials&lt;/code&gt; repo for API keys, and &lt;code&gt;scripts&lt;/code&gt; for custom CLI utilities. Every project carries two markdown files: &lt;code&gt;CLAUDE.md&lt;/code&gt; as static instructions on how to build and deploy the project, and &lt;code&gt;WORKLOG.md&lt;/code&gt; as a running session journal recording what was investigated, changed, and decided so the next session can pick right back up.&lt;/p&gt;
&lt;p&gt;Small daily workflow tweaks remove even more friction: having Claude pipe output straight to the macOS clipboard via &lt;code&gt;pbcopy&lt;/code&gt;, capturing a screen region to the clipboard and pasting it directly into Claude instead of describing UI bugs in prose, and running a custom doctor script that verifies 30+ environment checks across his three Macs. He also breaks down how he separates Claude Code&amp;rsquo;s memories, skills, and hooks, configures his status bar to display rate-limit usage, and auto-titles terminal tabs by project name. Going faster, he notes, only makes you want to go faster still—every friction point removed builds momentum for the next.&lt;/p&gt;
&lt;h2 id="java-is-fast-your-code-might-not-be"&gt;&lt;a href="https://jvogel.me/posts/2026/java-is-fast-your-code-might-not-be/" rel="noopener noreferrer"&gt;Java Is Fast. Your Code Might Not Be.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jonathan Vogel built a Java order-processing service for a DevNexus talk that worked outer-loop fine and passed every test—then fixed eight common performance anti-patterns without changing the architecture or upgrading the JDK. Processing time dropped from 1,198ms to 239ms, throughput jumped from 85,000 to 419,000 orders per second, and heap usage fell from over 1GB to 139MB. What makes these eight anti-patterns dangerous is that they compile cleanly, slip past code review, and only stand out under a profiler.&lt;/p&gt;
&lt;p&gt;The eight culprits: string concatenation with &lt;code&gt;+&lt;/code&gt; inside loops causing O(n²) copying (use &lt;code&gt;StringBuilder&lt;/code&gt;); running a full &lt;code&gt;Stream&lt;/code&gt; scan over a list inside a loop—the single biggest hotspot, eating nearly 71% of CPU samples, replaced by a single-pass accumulation using &lt;code&gt;Map.merge()&lt;/code&gt;; calling &lt;code&gt;String.format()&lt;/code&gt; on hot paths; autoboxing &lt;code&gt;Long&lt;/code&gt; instead of primitive &lt;code&gt;long&lt;/code&gt;, churning ~16MB of heap garbage per million elements; using exceptions for normal control flow; overly coarse &lt;code&gt;synchronized&lt;/code&gt; blocks (replaced with &lt;code&gt;ConcurrentHashMap&lt;/code&gt; and &lt;code&gt;LongAdder&lt;/code&gt;); repeatedly instantiating expensive thread-safe objects like Jackson&amp;rsquo;s &lt;code&gt;ObjectMapper&lt;/code&gt;; and pinning virtual threads on JDK 21–23 by performing blocking I/O inside &lt;code&gt;synchronized&lt;/code&gt; blocks (fixed with &lt;code&gt;ReentrantLock&lt;/code&gt;). Part two of the series will walk through the exact JFR profiler traces.&lt;/p&gt;
&lt;h2 id="go-naming-conventions-a-practical-guide"&gt;&lt;a href="https://www.alexedwards.net/blog/go-naming-conventions" rel="noopener noreferrer"&gt;Go Naming Conventions: A Practical Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards puts together a comprehensive, practical guide to naming things in Go, starting from the language&amp;rsquo;s three hard rules for identifiers (only Unicode letters, digits, and underscores; cannot start with a digit; cannot match a reserved keyword) and moving into community conventions. Go uses &lt;code&gt;mixedCaps&lt;/code&gt; (&lt;code&gt;camelCase&lt;/code&gt;) for unexported identifiers and &lt;code&gt;ExportedCaps&lt;/code&gt; (&lt;code&gt;PascalCase&lt;/code&gt;) for exported ones, because the case of the first letter determines package visibility; &lt;code&gt;snake_case&lt;/code&gt; is almost never used. Initialisms and acronyms keep consistent casing across the entire word: &lt;code&gt;apiKey&lt;/code&gt; and &lt;code&gt;APIKey&lt;/code&gt; are idiomatic, whereas &lt;code&gt;ApiKey&lt;/code&gt; is not; likewise, write &lt;code&gt;userID&lt;/code&gt;, never &lt;code&gt;userId&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For identifier length, the guiding principle is that the farther an identifier is used from its declaration, the more descriptive its name needs to be: a loop index over three lines can be &lt;code&gt;i&lt;/code&gt;, while a package-level variable needs a full, self-explanatory name. He advises against encoding types into variable names, shadowing built-in functions or standard-library package names like &lt;code&gt;json&lt;/code&gt; or &lt;code&gt;log&lt;/code&gt;, and exporting identifiers by default—citing &lt;em&gt;The Pragmatic Programmer&lt;/em&gt; that exporting less makes internal refactoring much easier. Package names should be short, all-lowercase single words without underscores (&lt;code&gt;ordermanager&lt;/code&gt;, not &lt;code&gt;order_manager&lt;/code&gt;), avoiding names with special toolchain meaning like &lt;code&gt;vendor&lt;/code&gt;, &lt;code&gt;testdata&lt;/code&gt;, or &lt;code&gt;internal&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="sambercc-skills-golang--a-collection-of-golang-agentic-skills-that-works"&gt;&lt;a href="https://github.com/samber/cc-skills-golang" rel="noopener noreferrer"&gt;samber/cc-skills-golang: 🧑‍🎨 A collection of Golang agentic skills that works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This open-source repository offers a curated collection of Go-specific agent skills compatible with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and Antigravity. Each skill is a modular instruction pack loaded only when relevant, keeping the coding agent&amp;rsquo;s context window lean. Bootstrapped with Claude Code from the author&amp;rsquo;s own production Go commits and then heavily edited, tested, and rewritten by hand, the project comes with a blunt warning from the author: purely AI-generated skills are useless.&lt;/p&gt;
&lt;p&gt;The catalog spans code style, naming conventions, data structures, database patterns, design patterns, documentation, error handling, observability, performance, benchmarking, security, and testing. Skills are split into small, cross-referenced units—for instance, rules about logging errors live inside &lt;code&gt;golang-error-handling&lt;/code&gt; rather than &lt;code&gt;golang-observability&lt;/code&gt;. Each skill includes benchmarked error-reduction numbers comparing agent output with and without the skill, such as a ~40% reduction in style violations and a 53% improvement in documentation compliance. Skills can be installed via the &lt;code&gt;skills&lt;/code&gt; CLI, the Claude Code plugin marketplace, or by copying them into your tool&amp;rsquo;s skill discovery directory.&lt;/p&gt;
&lt;h2 id="small-programming-tricks"&gt;&lt;a href="https://will-keleher.com/posts/small-programming-tricks-matter/" rel="noopener noreferrer"&gt;Small Programming Tricks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Keleher argues that a surprising share of day-to-day engineering speed comes from accumulating &amp;ldquo;small programming tricks&amp;rdquo;—bite-sized techniques that don&amp;rsquo;t require deep theoretical study, but pay off immediately every day. His favorites include fuzzy-searching shell history with &lt;code&gt;fzf&lt;/code&gt; on &lt;code&gt;Ctrl+R&lt;/code&gt; (or &lt;code&gt;atuin&lt;/code&gt; for even richer history), running &lt;code&gt;SELECT&lt;/code&gt; without a &lt;code&gt;FROM&lt;/code&gt; clause to quickly test database functions, using &lt;code&gt;EXPLAIN ANALYZE&lt;/code&gt; to tune queries, word-boundary assertions (&lt;code&gt;\b&lt;/code&gt;) in regular expressions, the &amp;ldquo;git pickaxe&amp;rdquo; (&lt;code&gt;git log -S&lt;/code&gt;) to find commits that added or removed a specific string, and &lt;code&gt;git checkout -&lt;/code&gt; to jump back to the previous branch or commit checkout.&lt;/p&gt;
&lt;p&gt;He also calls out modern JavaScript conveniences like &lt;code&gt;Array.flatMap&lt;/code&gt;, &lt;code&gt;Object.entries&lt;/code&gt;, and &lt;code&gt;Promise.withResolvers&lt;/code&gt;, and recommends &lt;code&gt;ripgrep&lt;/code&gt; (&lt;code&gt;rg&lt;/code&gt;) over &lt;code&gt;grep&lt;/code&gt; alongside shell globs like &lt;code&gt;**/*.md&lt;/code&gt; in place of verbose &lt;code&gt;find&lt;/code&gt; invocations. Inside a company, tribal-knowledge tricks—like which internal dashboard actually shows the right logs for a given failure, or who on another team knows a legacy subsystem inside out—are even more valuable. At a previous job, the author posted one small trick a day in Slack; that daily cadence was lightweight enough not to overwhelm anyone while steadily leveling up the whole team.&lt;/p&gt;
&lt;h2 id="shell-tricks-that-actually-make-life-easier-and-save-your-sanity"&gt;&lt;a href="https://blog.hofstede.it/shell-tricks-that-actually-make-life-easier-and-save-your-sanity/" rel="noopener noreferrer"&gt;Shell Tricks That Actually Make Life Easier (And Save Your Sanity)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christian Hofstede-Kuhn rounds up terminal shortcuts and shell features that many developers miss once they get comfortable with basic &lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;cd&lt;/code&gt;, and &lt;code&gt;grep&lt;/code&gt;. The first half covers Emacs-style line-editing keybindings (depending on your shell configuration): &lt;code&gt;Ctrl+W&lt;/code&gt; deletes the previous word, &lt;code&gt;Ctrl+U&lt;/code&gt; and &lt;code&gt;Ctrl+K&lt;/code&gt; cut to the start or end of the line, &lt;code&gt;Ctrl+Y&lt;/code&gt; yanks the cut text back, and &lt;code&gt;Ctrl+A&lt;/code&gt; / &lt;code&gt;Ctrl+E&lt;/code&gt; jump to the beginning or end of the line; &lt;code&gt;cd -&lt;/code&gt; toggles between your current and previous directory, while &lt;code&gt;pushd&lt;/code&gt; and &lt;code&gt;popd&lt;/code&gt; manage a directory stack. For scripts, &lt;code&gt;set -e&lt;/code&gt; and &lt;code&gt;set -u&lt;/code&gt; help catch errors early (though they have sharp edges and don&amp;rsquo;t replace explicit error handling, and &lt;code&gt;pushd&lt;/code&gt;/&lt;code&gt;popd&lt;/code&gt; aren&amp;rsquo;t part of POSIX &lt;code&gt;sh&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The second half focuses on Bash and Zsh power tools: reverse history search with &lt;code&gt;Ctrl+R&lt;/code&gt;, pressing &lt;code&gt;Ctrl+X&lt;/code&gt; then &lt;code&gt;Ctrl+E&lt;/code&gt; to open the current command line in your &lt;code&gt;$EDITOR&lt;/code&gt; when crafting a complex multi-line command, brace expansion like &lt;code&gt;cp file{,.bak}&lt;/code&gt; for quick backups or &lt;code&gt;mkdir -p project/{src,tests,docs}&lt;/code&gt; to scaffold directories in one shot, process substitution like &lt;code&gt;diff &amp;lt;(sort file1) &amp;lt;(sort file2)&lt;/code&gt;, and &lt;code&gt;disown&lt;/code&gt; to detach a long-running job from the current shell session. His advice: don&amp;rsquo;t try to memorize the whole list at once—pick one trick, force yourself to use it for a week, and then move on to the next.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #93</title><link>https://miti99.com/en/post/2026/03/28/</link><pubDate>Sat, 28 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #93.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="lessons-from-building-claude-code-how-we-use-skills"&gt;&lt;a href="https://x.com/trq212/status/2033949937936085378" rel="noopener noreferrer"&gt;Lessons from Building Claude Code: How We Use Skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thariq Shihipar, an engineer at Anthropic, distills lessons from running hundreds of internal skills in Claude Code. The first misconception he corrects is that skills are &amp;ldquo;just markdown files&amp;rdquo;: each skill is actually a directory that can bundle scripts, reference assets, and data for the agent to discover and execute, along with configuration options like dynamic hook registration. Surveying their internal catalog, the team found that effective skills fall into nine recurring categories: library and API references, product verification, data fetching and analysis, team workflow automation, code scaffolding, code quality enforcement, CI/CD and deployment, incident runbooks, and infrastructure operations. Great skills fit cleanly into one category; confusing ones straddle several.&lt;/p&gt;
&lt;p&gt;When authoring skills, he advises skipping obvious instructions and focusing on where you need to nudge Claude away from its default habits—a &amp;ldquo;Gotchas&amp;rdquo; section built up from real failure modes is consistently the highest-leverage part. The frontmatter &lt;code&gt;description&lt;/code&gt; isn&amp;rsquo;t a human summary; it tells the model &lt;em&gt;when&lt;/em&gt; to trigger the skill. Skills can persist per-user settings in &lt;code&gt;config.json&lt;/code&gt; (prompting via &lt;code&gt;AskUserQuestion&lt;/code&gt; when missing), keep lightweight &amp;ldquo;memory&amp;rdquo; in append-only logs or JSON files inside a stable data directory, and ship helper scripts so Claude spends turns composing tools rather than regenerating boilerplate. Finally, skills can reference one another by name, and the team tracks skill invocations via a &lt;code&gt;PreToolUse&lt;/code&gt; hook to spot popular skills and prune dead ones.&lt;/p&gt;
&lt;h2 id="the-future-of-software-engineering-with-anthropic"&gt;&lt;a href="https://www.akashbajwa.co/p/the-future-of-software-engineering" rel="noopener noreferrer"&gt;The Future Of Software Engineering with Anthropic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Akash Bajwa summarizes a roundtable with Anthropic&amp;rsquo;s Ash Prabaker and engineering leaders from Stripe, NVIDIA, Microsoft, Google DeepMind, xAI, Apple, Scale AI, and OpenAI on how AI is reshaping software development. Claude Code started in late 2024 as a humble CLI built not for the models of the day, but for where model capabilities would be six to twelve months later—and spread organically through bottom-up utility rather than top-down mandates. A recurring theme is the recursive improvement loop: better coding tools help build better models, which in turn improve the tools; several companies already run pipelines that autonomously triage production bugs, cross-check against eval suites, and open fix PRs with minimal human intervention.&lt;/p&gt;
&lt;p&gt;Across engineering workflows, test-first development has become the default, human code review increasingly feels more like a bottleneck than a safety net, and inline code comments are making a comeback because future agent sessions rely on them. Human-written architectural context remains invaluable, whereas stale or auto-generated documentation actively misleads agents. In hiring, several leaders now prize engineers who experiment relentlessly at the frontier of tool capabilities over raw hand-coding speed. Open challenges include multi-hour autonomous agent runs that still preserve meaningful human oversight, large-scale context management, and the paradox that when AI makes building almost anything feasible, ruthless prioritization becomes harder than ever.&lt;/p&gt;
&lt;h2 id="rob-pike"&gt;&lt;a href="https://www.cs.unc.edu/~stotts/COMP590-059-f24/robsrules.html" rel="noopener noreferrer"&gt;Rob Pike&amp;rsquo;s 5 Rules of Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rob Pike, co-creator of Go and veteran of Bell Labs, distilled five pithy rules of programming included here in the course readings for COMP590 at UNC. Rules 1 and 2 address optimization: you cannot tell in advance where a program will spend its time because bottlenecks show up in surprising places, so don&amp;rsquo;t put in speed hacks until you&amp;rsquo;ve measured and proven that one part of the code overwhelms the rest. Together, they restate Tony Hoare&amp;rsquo;s famous maxim that &amp;ldquo;premature optimization is the root of all evil.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Rules 3 and 4 warn that fancy algorithms have big constant factors that make them slow when &lt;code&gt;n&lt;/code&gt; is small—and &lt;code&gt;n&lt;/code&gt; is usually small—and they are much buggier and harder to implement, so stick to simple algorithms and simple data structures; as Ken Thompson put it, &amp;ldquo;when in doubt, use brute force.&amp;rdquo; Rule 5 is the heart of the list: data dominates. Once you&amp;rsquo;ve chosen the right data structures and organized things well, the algorithms will almost always be self-evident; data structures, not algorithms, are central to programming.&lt;/p&gt;
&lt;h2 id="introduction-to-postgresql-indexes"&gt;&lt;a href="https://dlt.github.io/blog/posts/introduction-to-postgresql-indexes/" rel="noopener noreferrer"&gt;Introduction to PostgreSQL Indexes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dalto Curvelano explains the internals of PostgreSQL indexes for developers who have an intuitive grasp of indexes but want to understand how they work under the hood. The article starts with how rows live inside 8KB heap pages and why indexes cut down page reads: in a benchmark on a million-row table, a sequential scan takes ~265ms while an index lookup takes just 0.077ms. As a rule of thumb, an index only pays off when a query returns less than roughly 15–20% of the table; beyond that, the query planner usually prefers a sequential scan. Nor are indexes free: they consume disk space, slow down &lt;code&gt;INSERT&lt;/code&gt;/&lt;code&gt;UPDATE&lt;/code&gt;/&lt;code&gt;DELETE&lt;/code&gt; operations, occupy buffer cache memory, and give the query planner more paths to evaluate, so they shouldn&amp;rsquo;t be sprinkled everywhere.&lt;/p&gt;
&lt;p&gt;Most of the guide surveys PostgreSQL&amp;rsquo;s index types. B-Tree is the versatile default; starting in PostgreSQL 18, B-Tree skip scan allows composite indexes to be used even when a query omits the leading column. Hash indexes only support equality checks, but are more compact than B-Trees on wide values like UUIDs or URLs; BRIN indexes are tiny and shine on append-only, naturally ordered time-series tables; GIN handles full-text search, arrays, and &lt;code&gt;JSONB&lt;/code&gt;; and GiST/SP-GiST cover geometric and range data. The post also walks through partial indexes (indexing only a filtered subset of rows), covering indexes with &lt;code&gt;INCLUDE&lt;/code&gt; (enabling index-only scans when the visibility map allows skipping heap fetches), and expression indexes over computed values.&lt;/p&gt;
&lt;h2 id="using-rust-and-postgres-for-everything-patterns-learned-over-the-years"&gt;&lt;a href="https://kerkour.com/rust-postgres-everything" rel="noopener noreferrer"&gt;Using Rust and Postgres for everything: patterns learned over the years&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sylvain Kerkour shares the architectural patterns he has refined from running Rust and PostgreSQL as the backbone for nearly every backend project—guided by a philosophy of picking boring, dependable tools to minimize operational cost and complexity. He opens with a real-world rewrite of a data-processing service from Go to Rust paired with a high-performance memory allocator: batch processing time dropped from roughly 30 minutes to under 5 minutes, RAM usage fell from 4GB to 512MB, and nil-pointer panics disappeared entirely.&lt;/p&gt;
&lt;p&gt;On the application side, he favors &lt;code&gt;sqlx&lt;/code&gt; over heavy ORMs for its simplicity, performance, and compile-time SQL verification macros, and batches writes in chunks of up to 10,000 rows using &lt;code&gt;UNNEST&lt;/code&gt; to avoid overwhelming the database. Even better, PostgreSQL replaces a sprawl of auxiliary infrastructure: &lt;code&gt;pg_try_advisory_lock()&lt;/code&gt; handles leader election (for instance, coordinating distributed CRON schedulers) without ZooKeeper or Redis; &lt;code&gt;UNLOGGED&lt;/code&gt; tables replace Redis for ephemeral caches by skipping the WAL for much faster writes at the cost of crash durability; and PostgreSQL serves as a rock-solid job queue when combining UUIDv7 primary keys (to avoid B-tree index fragmentation) with &lt;code&gt;FOR UPDATE SKIP LOCKED&lt;/code&gt; for worker polling.&lt;/p&gt;
&lt;h2 id="air-traffic-control-the-ibm-9020"&gt;&lt;a href="https://computer.rip/2026-01-17-air-traffic-control-9020.html" rel="noopener noreferrer"&gt;air traffic control: the IBM 9020&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;J. B. Crawford tells the story of the IBM 9020—the custom multiprocessor mainframe built for the US Federal Aviation Administration (FAA) to automate en-route air traffic control, with the first full system installed in 1967. Earlier, the military&amp;rsquo;s SAGE air-defense computer had been considered for civilian traffic control, but it couldn&amp;rsquo;t verify whether assigned altitudes were unique or detect loss of safe separation between aircraft at a time when mid-air collisions were an urgent political crisis.&lt;/p&gt;
&lt;p&gt;Under the hood, an IBM 9020 tied together six or seven modified System/360 compute elements sharing memory through dedicated Storage Elements, orchestrated by a real-time control program managing hundreds of radar and display peripherals. Its standout engineering achievement was fault tolerance: when a hardware fault occurred, the Operational Error Analysis Program (OEAP) automatically diagnosed the failure, ignored transient glitches, or rewrote configuration registers on the fly to isolate a failed compute or storage element so air traffic control could continue uninterrupted. The 9020 stayed in service into the mid-1980s—with display subsystems lasting into the 1990s—proving that commercial-grade computer architectures could handle life-critical workloads when paired with disciplined redundancy and fault-recovery software.&lt;/p&gt;
&lt;h2 id="sfq-simple-stateless-stochastic-fairness"&gt;&lt;a href="https://brooker.co.za/blog/2026/02/25/sfq.html" rel="noopener noreferrer"&gt;SFQ: Simple, Stateless, Stochastic Fairness&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker highlights Stochastic Fairness Queuing (SFQ), an algorithm from a 1990 paper by Paul McKenney and one of his favorite compact building blocks for distributed systems. Classic fair queuing maintains a separate queue per tenant, requiring O(tenants) queues and matching scheduling overhead—impractical at cloud scale. SFQ instead allocates a fixed O(1) array of queues and hashes each tenant ID to a queue. Because two tenants that hash to the same bucket would stay stuck together if one is a &amp;ldquo;noisy neighbor,&amp;rdquo; SFQ periodically rotates the hash seed so tenants that collide in one epoch are overwhelmingly unlikely to collide in the next.&lt;/p&gt;
&lt;p&gt;Brooker then describes a modern variant combining SFQ with shuffle sharding and the power of two choices: each tenant is hashed to a small subset of queues (often just two), each incoming request is placed into whichever of those queues is shorter, and the hash seed rotates periodically. The result keeps queue count, enqueue cost, and dequeue cost at O(1) while strongly isolating noisy neighbors from well-behaved tenants—as long as noisy tenants are a small fraction of the population. The pattern works both inside a single multi-tenant server and across a fleet of backend workers.&lt;/p&gt;
&lt;h2 id="how-many-branches-can-your-cpu-predict"&gt;&lt;a href="https://lemire.me/blog/2026/03/18/how-many-branches-can-your-cpu-predict/" rel="noopener noreferrer"&gt;How many branches can your CPU predict?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire measures how many conditional branches a modern CPU&amp;rsquo;s branch predictor can &amp;ldquo;memorize.&amp;rdquo; His benchmark loops over an array of random integers and conditionally writes to a buffer only when a value is odd—so on fresh random data, the CPU mispredicts roughly 50% of the time. However, if you repeatedly loop over the &lt;em&gt;exact same&lt;/em&gt; random sequence, the branch predictor learns the pattern; increasing the sequence length reveals the capacity threshold where the predictor overflows and performance drops back to random guessing. The results: AMD Zen 5 perfectly predicts sequences of roughly 30,000 branches, Apple&amp;rsquo;s M4 handles around 10,000, and Intel&amp;rsquo;s Emerald Rapids manages only about 5,000—six times fewer than Zen 5.&lt;/p&gt;
&lt;p&gt;The practical lesson is a warning for microbenchmarking: if your test input is small enough to fit inside the CPU&amp;rsquo;s branch history tables, the processor will memorize the exact branch pattern and report numbers far faster than what you will ever see on real production traffic. Reliable benchmarks require input datasets large and varied enough to defeat branch memorization.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!tS1T!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F958d36d9-6b19-4949-b6a6-6aa614ede834_2508x2960.jpeg" alt="Different Types of Tests"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!c4WE!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd86cd367-494f-4031-9793-f27e6142e54b_2508x3000.png" alt="How Single Sign-On (SSO) Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!em-f!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7e7e23e9-2a5a-4b06-a3fa-ccb6c5493f1d_2508x3000.png" alt="How LLMs Use AI Agents with Deep Research"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!kRPi!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F3d3b2bb9-fc09-48d9-89b7-52bc37098af9_2360x2960.png" alt="How hackers steal passwords"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #87</title><link>https://miti99.com/en/post/2026/03/02/</link><pubDate>Mon, 02 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #87.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="on-cognitive-debt"&gt;&lt;a href="https://www.natemeyvis.com/on-cognitive-debt/" rel="noopener noreferrer"&gt;On cognitive debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;There has been plenty of talk lately about &amp;ldquo;cognitive debt&amp;rdquo;: when AI-generated code grows so fast that nobody understands how it works anymore, making it hard to extend, observe, and debug. Nate Meyvis agrees the phenomenon is real, but argues the panic is overblown. Compared at the same project size, cognitive debt in pre-AI codebases was often even worse; AI simply lets us move several times faster, so we hit that complexity wall much sooner. We miss this because much of what we treat as &amp;ldquo;normal engineering&amp;rdquo;—like a handful of senior engineers carrying all the implicit constraints in their heads—is actually the tax of cognitive debt. When a local change breaks a distant part of the system and tests don&amp;rsquo;t catch it, that usually means encapsulation had already failed.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, skilled AI users already know how to keep cognitive debt in check and will keep getting better at it. He shares several practices: emphasizing encapsulation in project-level AI instructions, clearly documenting subsystems, their interfaces, and data structures, leaning into large-scale refactoring with AI (which is much less painful now), and adding tests wherever cognitive debt starts to show. The takeaway: cognitive debt is real, but we fix it by using AI better rather than blaming AI for our own engineering habits.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://davidoks.blog/p/why-im-not-worried-about-ai-job-loss" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m not worried about AI job loss&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Oks responds to Matt Shumer&amp;rsquo;s viral essay &amp;ldquo;Something Big Is Happening,&amp;rdquo; which compared the present moment to February 2020 right before COVID hit and warned of mass unemployment. Oks believes AI will be as consequential as electricity or the steam engine, but argues its real-world impact on jobs will be much slower and more uneven. First, labor substitution is governed by comparative advantage, not absolute advantage: even if AI outperforms humans at every task, pairing humans with AI remains worthwhile whenever combined output is higher—which is visibly true in software engineering today. Second, the world is full of human-made bottlenecks: regulation, corporate culture, politics, habit, and above all resistance to change. That is why, even with capable models available for years, outsourced customer support still hasn&amp;rsquo;t been replaced wholesale.&lt;/p&gt;
&lt;p&gt;Third, demand for many goods and services is more elastic than we assume, so efficiency gains are often absorbed by rising demand, just as Jevons paradox predicts; every past leap in programming productivity ended up increasing demand for software engineers. Over the long run, humans will keep inventing new kinds of work that blur the line between labor and leisure. The author concludes that ordinary workers will be fine; the real danger is a populist backlash fueled by doomerism, which could lead to bans on data center construction and choke off the benefits AI can bring.&lt;/p&gt;
&lt;h2 id="why-i-don"&gt;&lt;a href="https://honnibal.dev/blog/ai-bubble" rel="noopener noreferrer"&gt;Why I don&amp;rsquo;t think AI is a bubble&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthew Honnibal, creator of the spaCy NLP library, sets aside the financial side of the &amp;ldquo;AI bubble&amp;rdquo; debate to answer the technical question: is AI progress about to plateau? The common argument is that recent gains came from brute-force scaling, returns are diminishing, and we are about to hit a wall. He admits he thought the same back in the GPT-1 and GPT-2 days, but underestimated reinforcement learning (RL). Reasoning models like Claude Opus or GPT-5 combine generative pre-training on massive text corpora with AlphaZero-style RL: the model generates intermediate steps, and chains of steps that lead to verifiable correct answers get reinforced. &amp;ldquo;Logic is work&amp;rdquo;: even in a purely symbolic system, deduction requires computation, so generating intermediate steps is essential rather than a parlor trick.&lt;/p&gt;
&lt;p&gt;The scaling-wall argument only applies to next-token pre-training. Reasoning opens up two new levers: letting models run longer at inference time to think through harder problems, and scaling up reinforcement learning; combined with the ability to backtrack from dead ends, models can search the solution space much like exploring moves in chess. Nor does RL face an obvious data wall, because verifying a successful chain of reasoning is far easier than generating one from scratch. While he doesn&amp;rsquo;t trust OpenAI as a company, he sees no technical reason to think progress is about to stop, and expects the new data centers to be put to productive use.&lt;/p&gt;
&lt;h2 id="i-guess-i-kinda-get-why-people-hate-ai"&gt;&lt;a href="https://anthony.noided.media/blog/ai/programming/2026/02/14/i-guess-i-kinda-get-why-people-hate-ai.html" rel="noopener noreferrer"&gt;I guess I kinda get why people hate AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from a hotel balcony in Hawaii nine days before starting a new job, the author wonders whether this will be the last job he ever has. Once, that question meant wondering whether he&amp;rsquo;d ever &lt;em&gt;need&lt;/em&gt; to work again; now it means wondering whether AI will make him unemployable. He doesn&amp;rsquo;t hate AI, but he understands why so many people do. The most obvious reason: AI industry leaders actively market their products by boasting that they will wipe out jobs—something unprecedented in the history of technology. If they genuinely believed that, he argues, they would be lobbying right now for trigger laws, such as automatic tax hikes to fund retraining or universal basic income if unemployment rises while GDP grows. That nobody is proposing this suggests they either don&amp;rsquo;t believe their own hype or don&amp;rsquo;t care about the fallout.&lt;/p&gt;
&lt;p&gt;Meanwhile, everyday encounters with AI for ordinary people are mostly negative: students pasting homework into ChatGPT, deepfake Elon Musk videos fooling his dad, AI slop flooding TikTok, cURL shutting down its bug bounty program under a wave of fabricated vulnerability reports, and RAM prices spiking. AI &lt;em&gt;sometimes&lt;/em&gt; helps people do high-quality work, but it &lt;em&gt;always&lt;/em&gt; makes generating slop nearly free. He proposes concrete mitigations: watermarking AI-generated content, stricter YouTube enforcement against AI misinformation, and letting major open-source projects opt out of automated AI vulnerability scanning. What worries him most is that the AI labs barely seem to be trying.&lt;/p&gt;
&lt;h2 id="uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/ubers-rate-limiting-system/" rel="noopener noreferrer"&gt;Uber&amp;rsquo;s Rate Limiting System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber handles hundreds of millions of RPCs per second across thousands of microservices. Historically, teams built their own rate limiters—typically backed by Redis counters—leading to inconsistent configuration, added latency, and operational toil. Because centralized counters cannot scale to hundreds of thousands of instances across regions, Uber built GRL (Global Rate Limiter) directly into its service mesh, allowing rate limits per caller or procedure without code changes. GRL has three tiers: in-mesh clients make local per-request decisions, zone-level aggregators roll up usage metrics, and a regional controller computes global utilization and pushes drop directives back down. An initial token-bucket design distributed quota unfairly across callers, so the team switched to probabilistic dropping: when aggregate load exceeds the limit, every client drops a fraction of requests equal to &lt;code&gt;(actual − limit) / actual&lt;/code&gt;, updated every second. The trade-off is a 2–3 second reaction delay.&lt;/p&gt;
&lt;p&gt;Eliminating Redis cut median latency by ~1ms, P90 by tens of milliseconds, and improved P99.5 by up to 90%; the system has absorbed 15x traffic spikes and mitigated DDoS incidents. GRL now processes roughly 80 million requests per second across more than 1,100 services. To keep limits from going stale, Uber also built RLC (Rate Limit Configurator), which periodically analyzes recent weeks of traffic, computes safe limits from historical peaks plus headroom, and automatically rolls out updated configurations with a dry-run shadow mode before enforcement.&lt;/p&gt;
&lt;h2 id="agents-feb-2026"&gt;&lt;a href="https://calv.info/agents-feb-2026" rel="noopener noreferrer"&gt;Agents (Feb 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Calvin French-Owen, who helped launch Codex Web at OpenAI, shares how he uses coding agents as of February 2026. His own time is now the scarce resource: he picks tools based on how much time he has and how much autonomy he wants to grant. The core mental model is understanding context: an agent is just predicting the next token, and everything must fit inside the context window. From that follow several rules: break work into small chunks, remember that context compaction always loses information, persist state to the filesystem (such as numbered plan files with checkboxes), and stay inside the &amp;ldquo;smart half&amp;rdquo; of the context window. Opus in Claude Code works across multiple context windows remarkably well, eagerly spawns parallel sub-agents, uses tools effectively, and explains itself clearly. Codex (GPT-5.3) writes noticeably less buggy code, but runs slower because it doesn&amp;rsquo;t yet fan work out across multiple context windows. So he plans with Claude Code and implements with Codex.&lt;/p&gt;
&lt;p&gt;His setup uses a &lt;code&gt;plans/&lt;/code&gt; directory of numbered plans, parallel git worktrees, preview deployments per branch, a plan–implement–review loop, and automated review bots to catch bugs. Skills chain and automate recurring workflows with minimal token overhead; he only creates a skill after repeating a task several times, gradually building up &lt;code&gt;/commit&lt;/code&gt;, &lt;code&gt;/worktree&lt;/code&gt;, &lt;code&gt;/implement&lt;/code&gt;, &lt;code&gt;/address-bugs&lt;/code&gt;, and &lt;code&gt;/pr-pass&lt;/code&gt;. The main barriers to continuously running agents are context management and prompt-injection defense; increasingly, ideas, architecture, and project sequencing are the real bottlenecks.&lt;/p&gt;
&lt;h2 id="the-software-industrial-revolution"&gt;&lt;a href="https://cannoneyed.com/essays/software-industrial-revolution" rel="noopener noreferrer"&gt;The Software Industrial Revolution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, late 2025 was the moment AI coding agents truly clicked, kicking off the &amp;ldquo;Software Industrial Revolution.&amp;rdquo; Just as the Spinning Jenny in 1764 turned single-threaded hand spinning into a parallel process and drove cotton cloth prices down by more than 90% over half a century, AI is automating software production—until now an extraordinarily labor-intensive craft. Software has eaten the world: the tech sector accounts for roughly 35% of the S&amp;amp;P 500, and nearly 50% when communication services are included. Yet because building software was so expensive, business models were pushed toward VC-fueled growth-at-all-costs to capture a market and then extract monopoly rents, leading to the &amp;ldquo;enshittification&amp;rdquo; Cory Doctorow describes. A textbook example is Epic, which holds 42% of the US acute-care hospital market with margins above 30%, where the sheer cost of building complex enterprise software chokes off competition.&lt;/p&gt;
&lt;p&gt;When software becomes orders of magnitude cheaper to produce, we will get vastly more of it, demand for engineers may actually rise, the old VC playbook will fade, and more sustainable business models will emerge. Anyone—from a cancer researcher to a small-business owner—will be able to have AI build the exact tools they need, sparking an explosion of bespoke software across every industry. While hand-typing code is losing its premium, core engineering skills like domain modeling, managing complexity, and understanding how software interacts with the real world will matter more than ever.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #76</title><link>https://miti99.com/en/post/2026/01/05/</link><pubDate>Mon, 05 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #76.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="tcp-vs-udp-vs-grpc-choosing-the-right-protocol-for-your-architecture"&gt;&lt;a href="https://designgurus.substack.com/p/an-engineers-guide-to-basic-networking" rel="noopener noreferrer"&gt;TCP vs. UDP vs. gRPC: Choosing the Right Protocol for Your Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you call a local function, data moves entirely within a single machine&amp;rsquo;s memory; modern software, however, constantly communicates with databases, APIs, and browsers halfway around the world. Network protocols are the rules governing data formats, how conversations are opened and closed, and how errors are handled. This article starts at the transport layer with its two pillars: TCP and UDP. TCP prioritizes reliability: before sending data, both sides perform a three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;); the protocol then guarantees that every byte arrives intact and in order, automatically retransmits lost packets, and uses flow control and congestion control to avoid overwhelming the receiver. That makes TCP ideal when accuracy matters more than raw speed, such as database queries, email, and web pages. UDP is the opposite: connectionless, no handshake, no packet numbering, and any packet dropped in transit is gone for good; in exchange, latency is minimal, making it a great fit for live video streaming or online gaming, where dropping a frame is far better than pausing to wait for an old one.&lt;/p&gt;
&lt;p&gt;At the application layer, HTTP follows a request–response model using methods like &lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, and &lt;code&gt;DELETE&lt;/code&gt;, headers carrying metadata, and status codes like &lt;code&gt;200 OK&lt;/code&gt; or &lt;code&gt;404 Not Found&lt;/code&gt;. The HTTP version matters too: HTTP/1.1 processes requests one at a time per connection and suffers from head-of-line blocking when a slow resource holds up the entire page; HTTP/2 adds multiplexing so multiple requests and responses can run concurrently over a single TCP connection; and HTTP/3 drops TCP entirely in favor of QUIC (built on top of UDP) for better performance on lossy networks. Finally, WebSockets overcome HTTP&amp;rsquo;s unidirectional limitation: a connection begins as an HTTP request asking for an &amp;ldquo;upgrade&amp;rdquo; and then stays open so both client and server can push messages at any time without per-message header overhead—ideal for chat apps or live stock tickers that need low-latency bidirectional communication.&lt;/p&gt;
&lt;h2 id="software-engineering-in-2026"&gt;&lt;a href="https://benjamincongdon.me/blog/2025/12/29/Software-Engineering-in-2026/" rel="noopener noreferrer"&gt;Software Engineering in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Congdon observes that the biggest impact of LLM tooling so far is a dramatic drop in the marginal cost—both in time and money—of producing high-quality code. Because writing code is only one part of software engineering, the bottleneck is shifting elsewhere. He breaks an engineer&amp;rsquo;s job down into building, evolving, and operating distributed systems: the first two have become much cheaper and easier thanks to LLMs, while operations remains largely untouched. The market will expect engineers to harness LLM productivity, making the profession feel more &amp;ldquo;industrialized&amp;rdquo; yet also higher-leverage. As a result, investments in solid infrastructure pay off faster than ever: metrics, logging, feature flags, deployments, autoscaling, and configuration should be self-service for both humans and LLMs via ergonomic CLIs or MCP-ready APIs. CI infrastructure also becomes more critical as AI agents write more code, potentially justifying investments in property-based testing and formal verification—and since LLMs don&amp;rsquo;t mind writing tests, there is no longer any excuse for poor test coverage.&lt;/p&gt;
&lt;p&gt;He emphasizes human-guided abstractions: without clear guardrails, LLMs fill in the blanks with greedy solutions just to get CI green, steadily degrading the codebase. Module boundaries, library interfaces, and contracts between infrastructure and product layers become the primary levers for maintaining long-term quality. Human code review also becomes a new bottleneck: style issues should be offloaded to automated linters so reviewers can focus on hard-to-reverse decisions like interface changes, data persistence, and performance-critical paths. This creates a paradox for junior engineers, who need to develop &amp;ldquo;review taste&amp;rdquo; earlier while writing less code by hand to build that intuition. Project estimation variance will also widen, since cost now depends heavily on how amenable a task is to LLM automation. On build-versus-buy, thin CRUD-style SaaS tools will increasingly tilt toward &amp;ldquo;build&amp;rdquo; at mid-to-large companies, whereas infrastructure and compliance SaaS will change much less because operational costs haven&amp;rsquo;t fallen like development costs have.&lt;/p&gt;
&lt;h2 id="reflections-on-2025"&gt;&lt;a href="https://samuelalbanie.substack.com/p/reflections-on-2025" rel="noopener noreferrer"&gt;Reflections on 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Samuel Albanie looks back on 2025 across three themes in his trademark witty style. First is &amp;ldquo;The Compute Theory of Everything&amp;rdquo;: in 2021, the handcrafted architectural inductive biases he painstakingly designed for computer vision at VGG (Oxford) were swept aside by a simpler system backed by massive pre-training compute. He revisits Hans Moravec&amp;rsquo;s 1976 argument that intelligence is not about magical symbolic manipulation, but raw processing power—&amp;ldquo;with enough thrust, anything flies.&amp;rdquo; Moravec noted that AI capability scales in lockstep with researchers&amp;rsquo; access to faster hardware; since upcoming hardware clusters will make 2025&amp;rsquo;s supercomputers look like pocket calculators, Albanie believes we are nowhere near hitting a ceiling. His second theme is model evaluation: AI systems are becoming increasingly general, while our benchmarks remain narrow. METR&amp;rsquo;s approach measures the duration of tasks models can complete compared to a skilled human, which jumped from roughly 5 minutes in early 2024 to 4 hours and 49 minutes with Claude Opus 4.5 in late 2025, even as the surface area needing evaluation has exploded from MNIST digit recognition to nearly the entire economy.&lt;/p&gt;
&lt;p&gt;His final theme, &amp;ldquo;Floreat Britannia,&amp;rdquo; examines the UK: real wages grew 33% per decade from 1970 to 2007 before stalling out, industrial electricity prices are the highest in Europe, the Hinkley Point C nuclear plant cost £46 billion, and an acoustic fish deterrent system alone cost roughly £700 million while projected to save just 0.083 salmon per year. In his view, the bottleneck is coordination and decision-making, and he is optimistic that AI will make high-quality probabilistic forecasting cheap and ubiquitous. Still, good forecasts are useless if the culture is paralyzed by risk aversion; invoking Benjamin Franklin flying a kite in a thunderstorm and inventing the lightning rod, he concludes that Britain needs both boldness and prudence—both the &amp;ldquo;kite&amp;rdquo; and the &amp;ldquo;lightning rod.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="8-predictions-for-2026-what-comes-next-in-ai"&gt;&lt;a href="https://www.philschmid.de/2026-predictions" rel="noopener noreferrer"&gt;8 Predictions for 2026. What comes next in AI?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philipp Schmid rarely writes prediction posts, but after a watershed 2025, he outlines eight AI trends for 2026. Generative UI will take off once code-generation latency and quality are good enough for apps to synthesize bespoke interfaces in real time tailored to each user&amp;rsquo;s task and preferences. Personal agents will move to the edge, powered by Small Language Models (SLMs) running locally on dedicated hardware. The smart home will finally deliver on its promise as assistants understand context and intent rather than rigid voice commands, blending into general assistants like the Gemini or ChatGPT apps. As traditional benchmarks saturate, AI labs will compete on &amp;ldquo;harnesses&amp;rdquo;—complex environments that prove agents can reliably execute multi-day workflows. Vibe coding will mature into real engineering: engineers will spend 99% of their time reviewing, evaluating, shaping ideas, and thinking, with the core skill being connecting implementation details, code quality, velocity, and business goals; knowing how to code becomes a distinct competitive advantage.&lt;/p&gt;
&lt;p&gt;His remaining three predictions revolve around social media: &amp;ldquo;AI slop&amp;rdquo; will turn human-created content into a premium market; every post on X, Instagram, or LinkedIn will be assumed AI-generated by default unless it carries a cryptographic signature under a &amp;ldquo;Human-Signed&amp;rdquo; metadata standard (like C2PA for cameras), with unsigned content downranked by algorithms as &amp;ldquo;synthetic noise&amp;rdquo;; and to fight agent spam, platforms will carve out a &amp;ldquo;verified human web&amp;rdquo; requiring biometric proof of personhood. In closing, he isn&amp;rsquo;t worried about the future of software engineers and believes learning to code is still well worth it, as deep technical understanding is more important than ever for steering these systems. His advice: build and learn—closely observe what others are building, dissect the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; and build your own version. Agents will remain center stage as successful patterns from coding agents spread to general-purpose agents that proactively anticipate needs rather than waiting for prompts.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #36</title><link>https://miti99.com/en/post/2025/07/25/</link><pubDate>Fri, 25 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/25/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #36.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-makes-strong-engineers-strong"&gt;&lt;a href="https://www.seangoedecke.com/what-makes-strong-engineers-strong/" rel="noopener noreferrer"&gt;What Makes Strong Engineers Strong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that what separates strong engineers from the rest is their ability to tackle unfamiliar problems faster than anyone else, and he ranks the four traits behind that ability in descending order of importance. First is self-belief: strong engineers take on work they have never done before even when they aren&amp;rsquo;t sure how, dive straight into hard problems instead of procrastinating, and let each success build the confidence to take on even harder work in a compounding loop. Second is pragmatism: they value working solutions over architectural purity, happily make trade-offs to ship on time, and frequently clash with smart but ineffective engineers over unnecessary rewrites; when disputes arise, who actually ships is the ultimate tiebreaker.&lt;/p&gt;
&lt;p&gt;Third is speed. Every strong engineer works fast—by not procrastinating and by compounding experience rapidly—and that speed lets them run more experiments and pursue high-value ideas. That pace comes not from working longer hours, but from intense bursts of focus. Last on the list is raw technical ability: a solid baseline is required, but genius-level intellect isn&amp;rsquo;t; what matters is whether your strengths match the job, and raw intelligence can even get in the way if it undermines pragmatism and speed.&lt;/p&gt;
&lt;h2 id="how-do-ai-code-reviews-impact-engineering-teams"&gt;&lt;a href="https://rdel.substack.com/p/rdel-92-how-do-ai-code-reviews-impact" rel="noopener noreferrer"&gt;How do AI Code Reviews Impact Engineering Teams?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post summarizes a study at Beko in which 238 developers used a GPT-4-powered automated code review tool (Qodo PR-Agent) over ten months, analyzing 4,335 pull requests through surveys and behavioral telemetry. Developers acted on 73.8% of the AI&amp;rsquo;s comments, and 68.8% of participants felt code quality improved. However, median pull-request cycle time actually increased from 5 hours 52 minutes to 8 hours 20 minutes, human reviewer comments barely budged (from 0.31 to 0.28 per pull request), and 26.2% of AI comments were ignored as irrelevant—meaning noisy suggestions created extra triage overhead.&lt;/p&gt;
&lt;p&gt;The core takeaway is that AI code review complements human reviewers rather than replacing them: it improves perceived quality, but neither reduces overall review effort nor speeds up delivery. The study advises teams to treat AI comments as early signal rather than final verdicts, track metrics to measure real impact on quality and velocity, and invest early in prompt tuning and noise filtering as the technology matures.&lt;/p&gt;
&lt;h2 id="writing-that-changed-how-i-think-about-pl"&gt;&lt;a href="https://bernsteinbear.com/blog/pl-writing/" rel="noopener noreferrer"&gt;Writing that changed how I think about PL&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein curates 16 papers, blog posts, videos, and repositories that fundamentally reshaped how he thinks about programming languages and compilers. Highlights include Andy Wingo&amp;rsquo;s post making copying garbage collectors concrete and approachable; CF Bolz-Tereick&amp;rsquo;s optimizer series introducing union-find and using Z3 as a proof engine; Chris Fallin&amp;rsquo;s work on register-allocator correctness showing how to verify a system per-compilation rather than proving the compiler itself once and for all; Russ Cox&amp;rsquo;s regular-expression series explaining how nondeterministic automata become user-space &amp;ldquo;threads&amp;rdquo;; and Andrej Karpathy&amp;rsquo;s micrograd for learning neural networks from scratch without external libraries.&lt;/p&gt;
&lt;p&gt;What unites every entry on the list is turning abstract concepts into clean, compact implementations you can grasp in an afternoon instead of months of study. For younger developers curious about compilers and interpreters, it serves as both a high-signal reading list and a testament to the power of clear, concise technical writing.&lt;/p&gt;
&lt;h2 id="llms-are-making-me-dumber"&gt;&lt;del&gt;&lt;a href="https://vvvincent.me/llms-are-making-me-dumber/" rel="noopener noreferrer"&gt;LLMs are Making Me Dumber&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Vincent Cheng poses a provocative question: are large language models (LLMs) making us dumber? He shares personal observations on how AI is reshaping his own learning process and skill development.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;He points to the cognitive &amp;ldquo;shortcuts&amp;rdquo; AI makes tempting: using LLMs to finish coding projects without deeply understanding the codebase, solving math problems by letting AI generate the answer, or drafting emails without practicing writing. Those habits can atrophy problem-solving muscles and trade deep learning for short-term output speed.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;At the same time, Cheng acknowledges the immediate productivity gains and draws historical parallels to pocket calculators, GPS, and the Industrial Revolution. Recognizing the uncertainty around long-term effects, he argues for a deliberate middle ground.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;His prescription is to consciously protect core skills like independent thinking, decision-making, and sustained focus while using LLMs strategically without surrendering personal agency. As he writes: &amp;ldquo;Total offloading cripples real learning while maximizing short-term speed and output, and finding the right balance is critical.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="how-cursor-indexes-codebases-fast"&gt;&lt;a href="https://read.engineerscodex.com/p/how-cursor-indexes-codebases-fast" rel="noopener noreferrer"&gt;How Cursor Indexes Codebases Fast&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article breaks down how Cursor, the AI-first code editor, indexes an entire codebase so quickly. The pipeline runs in five steps: first, files are chunked locally on the user&amp;rsquo;s machine into meaningful segments; next, Cursor computes a Merkle tree—a hash tree across all eligible files—and syncs it with the server; those code chunks are then converted into vectors using an embedding model; the vectors and metadata such as line numbers and obfuscated file paths are stored in Turbopuffer, a remote vector database; finally, every ten minutes, Cursor compares the Merkle tree to detect modified files and syncs only the diffs. Rather than slicing by fixed character or token counts, smart chunking relies on abstract syntax trees (ASTs) via tools like tree-sitter to preserve semantic boundaries while staying within token limits.&lt;/p&gt;
&lt;p&gt;On privacy, according to Cursor&amp;rsquo;s documentation, raw source code is not persisted on Cursor&amp;rsquo;s servers after a request completes, and file paths are encrypted using a client-side secret key. When you ask a question, your query is embedded into a vector and matched against stored vectors to locate relevant code ranges; those lines are then read locally from disk and sent as context to the large language model. The Merkle tree is the key piece that makes change detection fast and incremental syncing practical, especially on large repositories where re-indexing from scratch would be prohibitively expensive.&lt;/p&gt;
&lt;h2 id="a-leap-year-check-in-three-instructions"&gt;&lt;a href="https://hueffner.de/falk/blog/a-leap-year-check-in-three-instructions.html" rel="noopener noreferrer"&gt;A Leap Year Check in Three Instructions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Falk Hüffner presents a leap-year check that compiles down to roughly three CPU instructions. The standard definition requires multiple conditions: divisible by 4, and not divisible by 100 unless also divisible by 400. Hüffner packs all of that logic into a single multiplication, a bitwise AND, and a comparison against &amp;ldquo;magic&amp;rdquo; constants: &lt;code&gt;return ((y * 1073750999u) &amp;amp; 3221352463u) &amp;lt;= 126976u;&lt;/code&gt;. To find those constants, he used the Z3 bitvector constraint solver to search a 96-bit space; starting from a small year range and expanding iteratively, about half an hour of search produced constants that hold for every year from 0 to 102,499. A 64-bit variant extends the valid range up to year 5,965,232,499 and is proven optimal using the same technique.&lt;/p&gt;
&lt;p&gt;On performance, benchmarking on an i7-8700K with predictable inputs (always testing 2025) shows almost no difference (0.65 ns vs. 0.69 ns). With random years, however, the branchless formula runs 3.8x faster than the standard implementation by avoiding branch misprediction penalties. Hüffner notes that real-world applications mostly check predictable years like the current one, so realistic benchmarks are needed before adopting this trick in places like CPython&amp;rsquo;s &lt;code&gt;datetime&lt;/code&gt; module. Still, it is a fun exercise in bit twiddling and using constraint solvers for algorithmic optimization.&lt;/p&gt;
&lt;h2 id="reservoir-sampling"&gt;&lt;a href="https://samwho.dev/reservoir-sampling/" rel="noopener noreferrer"&gt;Reservoir Sampling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reservoir sampling is an algorithm for drawing a uniform random sample from a stream of items whose total length isn&amp;rsquo;t known in advance. It maintains a &amp;ldquo;reservoir&amp;rdquo; array of size &lt;code&gt;k&lt;/code&gt;, initialized with the first &lt;code&gt;k&lt;/code&gt; items of the stream (or all of them if the stream is shorter). Each subsequent item at 1-based index &lt;code&gt;n&lt;/code&gt; (where &lt;code&gt;n &amp;gt; k&lt;/code&gt;) is selected with probability &lt;code&gt;k/n&lt;/code&gt;; if chosen, it replaces a uniformly random element currently in the reservoir, and otherwise it is discarded. The math guarantees that the probability an older item survives in the reservoir equals the probability the new item is kept, giving every item seen so far an equal chance—just like every card in a deck having an equal chance of being drawn.&lt;/p&gt;
&lt;p&gt;Sam Rose illustrates the practical payoff with a log-ingestion service. During traffic spikes, instead of naively keeping only the first &lt;code&gt;k&lt;/code&gt; logs, reservoir sampling captures a fair, representative sample without overwhelming storage: memory usage stays strictly bounded at &lt;code&gt;k&lt;/code&gt; items, quiet periods record nearly every log, and peak periods automatically cap volume. Rose also touches on weighted variants that prioritize specific classes of items, such as error logs, for more nuanced sampling policies. Reservoir sampling cleanly solves a problem that sounds impossible at first glance: fair sampling when you don&amp;rsquo;t know how many items will arrive.&lt;/p&gt;
&lt;h2 id="beware-the-complexity-merchants"&gt;&lt;a href="https://chrlschn.dev/blog/2025/05/beware-the-complexity-merchants/" rel="noopener noreferrer"&gt;Beware the Complexity Merchants&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Chen warns against &amp;ldquo;complexity merchants&amp;rdquo;: engineers who introduce unnecessary complexity into systems, whether out of ego or to manufacture job security. By building Byzantine systems that only they understand, they carve out personal fiefdoms that constantly demand attention, budget, and headcount, then use the resulting pain to justify their own indispensability and influence—complete with the familiar refrain, &amp;ldquo;Who else is going to deal with all this complexity?&amp;rdquo; Chen quotes Ray Ozzie: &amp;ldquo;Complexity kills. It sucks the life out of developers; it makes products difficult to plan, build, and test.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;To push back, the post recommends requiring engineers to stabilize or simplify existing complexity before adding new layers, favoring &amp;ldquo;boring&amp;rdquo; battle-tested solutions over resume-driven tech, insisting on thorough documentation so systems can be handed off cleanly, staying skeptical of &amp;ldquo;silver bullet&amp;rdquo; pitches, and treating knowledge hoarding or deliberate obfuscation as red flags. The core message is that simple, well-documented systems enable shared team ownership and eliminate the environment complexity merchants rely on to build leverage.&lt;/p&gt;
&lt;h2 id="asserting-implications"&gt;&lt;a href="https://tigerbeetle.com/blog/2025-05-26-asserting-implications/" rel="noopener noreferrer"&gt;Asserting Implications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short note from TigerBeetle looks at how to write assertions for logical implications (&lt;code&gt;A ⇒ B&lt;/code&gt;) so they stay immediately readable. Most programming languages lack a dedicated implication operator, even though implications show up constantly in assertions. The textbook rewrite relies on the equivalence &lt;code&gt;A ⇒ B ⇔ ¬A ∨ B&lt;/code&gt;, yielding &lt;code&gt;assert(!a or b);&lt;/code&gt;, which forces the reader to mentally invert the condition to recover the original intent. The author recommends writing a plain conditional instead: &lt;code&gt;if (a) assert(b);&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;A real example from the TigerBeetle codebase makes the contrast clear: instead of &lt;code&gt;assert(header_b != null or replica.commit_min == replica.op_checkpoint);&lt;/code&gt;, write &lt;code&gt;if (header_b == null) assert(replica.commit_min == replica.op_checkpoint);&lt;/code&gt;. The second version states directly which condition triggers the check, making the invariant obvious at a glance. It is a tiny change, but a great reminder to optimize correctness checks for human readability.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #24</title><link>https://miti99.com/en/post/2025/05/11/</link><pubDate>Sun, 11 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #24.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="google"&gt;&lt;a href="https://newsletter.getdx.com/p/googles-principles-for-measuring-developer-productivity" rel="noopener noreferrer"&gt;Google&amp;rsquo;s principles for measuring developer productivity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abi Noda summarizes the paper &amp;ldquo;Measuring Productivity: All Models Are Wrong, But Some Are Useful&amp;rdquo; by Google researchers Ciera Jaspan and Collin Green. The core idea is that measuring developer productivity is fundamentally an exercise in modeling: every model omits details, so the goal is building a model that remains useful without creating perverse incentives. Drawing on years of internal research at Google, the authors distill five principles. First, avoid single-metric models, because no single metric captures the inherent trade-offs of engineering work. Second, measure all outcomes you care about and use multiple metrics per outcome; when two metrics measuring velocity move in opposite directions, that divergence is an important signal to investigate. Third, think carefully about the incentives your measurements create—when a measure becomes a target, it ceases to be a good measure. Fourth, cover all three dimensions of speed, ease, and quality rather than fixating on just one. Fifth, combine objective system logs with subjective self-reported survey data from engineers.&lt;/p&gt;
&lt;p&gt;The article closes with practical advice. If your team is small enough to fit into a single conference room, you don&amp;rsquo;t need productivity metrics—just sit down and talk to them. Larger organizations should start with developer surveys, which capture the holistic engineering experience far better than raw telemetry alone. Above all, define why you are measuring before choosing any metric.&lt;/p&gt;
&lt;h2 id="in-defense-of-ruthless-managers"&gt;&lt;a href="https://www.seangoedecke.com/ruthless-managers/" rel="noopener noreferrer"&gt;In defense of ruthless managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke divides engineering managers into two archetypes: empathetic managers, who invest emotionally in their reports and regularly go to bat for them against upper management, and &amp;ldquo;ruthless&amp;rdquo; managers, who view their job simply as transmitting the company&amp;rsquo;s needs to engineers and vice versa. While Goedecke agrees that having an empathetic manager is generally great, he argues that ruthless managers are underrated for five reasons. First, they still want their engineers to be happy, because happy engineers perform better, are easier to manage, and don&amp;rsquo;t quit. Second, they accumulate far more political capital with leadership, whereas empathetic managers who constantly push back on executives often burn through their capital right when you need them to advocate for your promotion. Third, they aren&amp;rsquo;t emotionally weighed down by hard decisions, so they stay focused and unbothered. Fourth, they communicate bluntly without sugarcoating bad news or parroting corporate talking points—though they may occasionally lie or withhold information out of self-interest. Finally, they are predictable because they always align with upper management&amp;rsquo;s priorities.&lt;/p&gt;
&lt;p&gt;Goedecke stresses that this defense only applies to competent managers inside reasonably healthy companies. An incompetent, ruthless manager is a recipe for disaster, and given a free choice, most engineers should still pick an empathetic boss. Since we rarely get to choose our managers, though, understanding the strengths of both styles makes it easier to work effectively with whichever one you have.&lt;/p&gt;
&lt;h2 id="ai-ambivalence"&gt;&lt;a href="https://nolanlawson.com/2025/04/02/ai-ambivalence/" rel="noopener noreferrer"&gt;AI ambivalence&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson holds a master&amp;rsquo;s degree in computational linguistics—having studied alongside the researchers who later coined the term &amp;ldquo;stochastic parrots&amp;rdquo;—but left the field because he grew tired of purely statistical approaches and preferred building software directly. For years he avoided generative AI: he was skeptical of AGI claims and disliked how autocomplete assistants turned programming into endlessly reading code rather than writing it. By 2025, with seemingly the entire industry adopting AI, he tried Claude and Claude Code and admitted they were far more capable than he expected: querying a large codebase, generating unit tests, or refactoring dozens of call sites to a new API pattern worked shockingly fast. The problem is that it drains the joy out of programming. He feels like a babysitter reviewing piles of machine-generated code for subtle bugs, where the strongest temptation is to stop reading altogether and surrender to &amp;ldquo;vibe coding.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Lawson doesn&amp;rsquo;t offer a neat conclusion, instead capturing a mood of deep ambivalence. He still uses AI for low-stakes tasks like throwaway prototypes and unit tests, but resents how generative AI has taken over software engineering and the underlying message—as Ezra Klein put it—that human creativity is merely derivative. Caught between adapting to the new normal and keeping his manual coding skills sharp for the day &amp;ldquo;vibe-coded&amp;rdquo; systems inevitably catch fire in production, he admits nobody truly knows how this plays out.&lt;/p&gt;
&lt;h2 id="use-abstraction-to-improve-function-readability"&gt;&lt;a href="https://testing.googleblog.com/2023/09/use-abstraction-to-improve-function.html" rel="noopener noreferrer"&gt;Use Abstraction to Improve Function Readability&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This installment of the Google Testing Blog&amp;rsquo;s Code Health series, written by Palak Bansal and Mark Manley, compares two versions of a &lt;code&gt;createPizza&lt;/code&gt; function in Go. The first version crams everything into a single function: preparing the dough and toppings, looping until the oven reaches temperature, baking the pizza, and boxing and slicing it. The second version consists of just three calls—&lt;code&gt;prepare&lt;/code&gt;, &lt;code&gt;bake&lt;/code&gt;, and &lt;code&gt;box&lt;/code&gt;—each of which delegates to lower-level helpers like &lt;code&gt;addToppings&lt;/code&gt; or &lt;code&gt;heatOven&lt;/code&gt; until reaching leaf functions that handle concrete implementation details without calling further helpers. The second version is far easier to read because the first mixes multiple levels of abstraction: low-level mechanics like polling the oven thermometer sit right alongside intermediate steps like baking and high-level intent.&lt;/p&gt;
&lt;p&gt;The takeaway is the Single Level of Abstraction principle: avoid mixing abstraction levels inside the same function, and instead compose functions at matching levels so the code reads top-to-bottom like a story with self-descriptive function names. This structure makes code easier to follow, debug, and reuse; the authors point readers to Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; for a deeper dive.&lt;/p&gt;
&lt;h2 id="how-apple-pay-handles-41-million-transactions-a-day-securely"&gt;&lt;a href="https://newsletter.systemdesign.one/p/how-does-apple-pay-work" rel="noopener noreferrer"&gt;How Apple Pay Handles 41 Million Transactions a Day Securely&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neo Kim breaks down Apple Pay&amp;rsquo;s architecture through the story of a traveler tapping an iPhone at a London Underground turnstile, noting that the post is based on public research and may differ from Apple&amp;rsquo;s internal implementation. When a user adds a card to Apple Wallet, the card details and device metadata are encrypted and routed through Apple to the payment network (such as Visa or Mastercard); the actual card number is never stored in full on the iPhone or on Apple&amp;rsquo;s servers. Once the payment network verifies the card with the issuing bank, it generates a Device Account Number (DAN)—an irreversible token bound to that specific card and iPhone pair—which is stored inside the iPhone&amp;rsquo;s Secure Element, a dedicated tamper-resistant hardware chip. At checkout, the point-of-sale terminal sends transaction details to the iPhone over NFC; the user authenticates via Touch ID or Face ID, and biometric data stays strictly inside the isolated Secure Enclave processor, never leaving the device.&lt;/p&gt;
&lt;p&gt;Next, the Secure Element combines the DAN with transaction details to compute a dynamic cryptogram—similar to a time-based one-time password—and sends the authorization request through the merchant&amp;rsquo;s acquirer without the merchant ever seeing the real card number. The payment network recomputes the cryptogram against its copy of the DAN to verify the transaction, then returns an approval code and a response cryptogram for the device to verify in turn. Built on the EMV contactless specification, Apple Pay works even when the iPhone has no cellular or Wi-Fi connection and is significantly safer than a physical card because the underlying card number is never exposed.&lt;/p&gt;
&lt;h2 id="four-kinds-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2023/four_kinds_of_optimisation.html" rel="noopener noreferrer"&gt;Four Kinds of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurence Tratt opens with two observations: programmers are chronically over-optimistic about knowing where their programs spend time, and equally over-optimistic about knowing how to speed up the slow parts. The cure for the first is disciplined profiling; for the second, Tratt outlines four categories of optimization, each with its own trade-offs. First, using a better algorithm requires understanding your data distribution: selection sort is three times faster than bubble sort on random data, but much slower on already-sorted data, and hand-rolled &amp;ldquo;fast&amp;rdquo; algorithms are notorious for subtle bugs. Second, using better data structures—such as a sorted array with binary search for read-heavy static data, or shrinking struct field sizes when allocating millions of instances. Third, moving to a lower-level system: rewriting Python in Rust might yield a 60x speedup, whereas running the exact same code on PyPy instead of CPython can deliver a 4x speedup with almost zero effort. Fourth, accepting a less accurate answer—including heuristic local search that may miss the global optimum, or probabilistic/lossy approaches like Bloom filters, JPEG compression, and machine learning.&lt;/p&gt;
&lt;p&gt;Tratt generally avoids jumping straight to a low-level rewrite because the return on engineering time is often poor, preferring simple wins first. He closes with three guiding rules: always pick the simplest optimization that meets your performance target because it introduces the fewest bugs; remember that human engineering time is expensive; and breadth of optimization knowledge matters more than narrow depth.&lt;/p&gt;
&lt;h2 id="the-fifth-kind-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2025/the_fifth_kind_of_optimisation.html" rel="noopener noreferrer"&gt;The Fifth Kind of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this follow-up post, Laurence Tratt admits he left out a fifth optimization technique that he relies on constantly: parallelization. When he parallelized his Rust-based static site builder across multiple threads, build times in &amp;ldquo;quick&amp;rdquo; mode dropped from roughly 0.6 seconds to under 0.3 seconds, while full &amp;ldquo;deploy&amp;rdquo; builds ran more than 3x faster. Similarly, his &lt;code&gt;lang_tester&lt;/code&gt; test harness runs test suites in parallel, cutting a test run on a 72-core machine from 37 seconds down to 2.5 seconds—a speedup that directly improves day-to-day developer flow.&lt;/p&gt;
&lt;p&gt;He reflects on why he overlooked parallelization the first time around. First is hardware history: consumer multicore CPUs only became mainstream around 2005, and it took years before x86 and Arm memory models were well-specified enough to program against reliably. Second is language support: Java only got a sound memory model with JSR 133 in 2004, C and C++ waited until 2011, and shared-memory multithreading remained fraught with data races such as lost updates or compilers optimizing away unsynchronized writes. Languages built around immutable data or actor models avoided most of these pitfalls but often paid a performance penalty. For Tratt, Rust changed the equation via the &lt;code&gt;Send&lt;/code&gt; and &lt;code&gt;Sync&lt;/code&gt; traits and ownership rules: he has yet to hit a single data race in Rust, even if occasional &lt;code&gt;clone()&lt;/code&gt; calls or subtle mutex deadlocks still crop up. Today, he designs for parallelism right from the start.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4036e9a7-f2b6-476c-ad5d-48916db3b610_1309x1536.gif" alt="REST API Design Best Practices"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2a933717-1d59-46a6-ba51-76e24ae048fc_1280x1502.gif" alt="How to Learn Backend Development?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b9397d70-0232-4a8b-8b3e-edd4c15eb9bb_800x939.gif" alt="The Simplified Git Workflow"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1bc9340f-de4f-4767-b2f8-f4c6529e9eea_1309x1536.gif" alt="Virtualization vs Containerization"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e7afaab-de4b-4604-a557-22974fb2e3ea_1280x1532.gif" alt="How Netflix Built a Distributed Counter?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=_d0duu3dED4" rel="noopener noreferrer"&gt;Why Everyone&amp;rsquo;s Talking About MCP?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #23</title><link>https://miti99.com/en/post/2025/05/10/</link><pubDate>Sat, 10 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #23.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="llms-an-operator"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/llms-an-operators-view" rel="noopener noreferrer"&gt;LLMs: An Operator&amp;rsquo;s View&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier looks at LLMs from the perspective of someone running an engineering organization. In his view, the baseline productivity floor for developers is rising: even skeptics acknowledge that tools like Copilot and Cursor speed up prototyping, code completion, and unit test generation. Engineering leaders should therefore proactively budget for paid seats and roll them out deliberately—surveying adoption, identifying internal champions to share workflows, and tracking impact over time. As individual output rises, teams can deliver more with fewer people, so before opening new headcount, leaders should first invest in tooling and training for their existing team, which costs a fraction of hiring another senior engineer.&lt;/p&gt;
&lt;p&gt;The flip side is that faster code generation does not automatically mean higher quality. Stanier recommends tightening code review practices—such as requiring multiple reviewers and running regular security refreshers for the team. Hiring is affected too: candidates using LLMs during remote interviews muddy evaluation signals, so companies need an explicit policy—either embracing AI tools and testing critical thinking, or banning them outright—and must communicate those rules upfront to candidates. The bottom line: adopting LLMs is now table-stakes infrastructure investment, paired with the guardrails needed to protect code quality and hiring standards.&lt;/p&gt;
&lt;h2 id="the-reality-of-tech-interviews-in-2025"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-reality-of-tech-interviews" rel="noopener noreferrer"&gt;The Reality of Tech Interviews in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, joined by Evan King (former Staff Engineer at Meta) and Stefan Mai (former Engineering Manager at Amazon and Meta), paints a picture of a tech hiring market that is simultaneously recovering and much tougher. Open roles at Big Tech are up roughly 40% year over year, and total tech job postings have climbed from their 2023 trough of 163,000 to around 230,000, though still far below the 2020–2022 peak. The recovery is highly uneven: AI infrastructure and ML ops roles command top-tier compensation, while new grads face brutal odds—one candidate applied to 100 companies, landed just 4 interviews, and received zero offers after six months. Mid-level loops have stretched out too, with one candidate going through eleven interview rounds before getting an offer.&lt;/p&gt;
&lt;p&gt;The bar for data structures, algorithms, and system design rounds has also risen noticeably: interviewers now expect complete, working solutions with proper error handling and input validation. Two standout trends are &amp;ldquo;downleveling&amp;rdquo;—where staff-level engineers accept senior roles after prolonged job searches—and &amp;ldquo;team matching&amp;rdquo; turning into an extra filtering stage that can stall offers for months. The authors advise preparing thoroughly for both technical and behavioral rounds at every level, especially for specialized roles, and lining up competing offers so you don&amp;rsquo;t get stuck in team-matching limbo.&lt;/p&gt;
&lt;h2 id="senior-developer-skills-in-the-ai-age-leveraging-experience-for-better-results"&gt;&lt;a href="https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/" rel="noopener noreferrer"&gt;Senior Developer Skills in the AI Age: Leveraging Experience for Better Results&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Manuel Kießling argues that AI coding agents like Cursor do not devalue senior engineering experience—they amplify it. While AI models have broad programming knowledge, they have almost no innate understanding of a project&amp;rsquo;s specific architecture, meaning results depend heavily on how a human guides them. Drawing on his team&amp;rsquo;s experience at Joboo, Kießling outlines three practices. First, well-structured requirements: clearly describing data relationships, system architecture, and task boundaries so the AI doesn&amp;rsquo;t wander off track. Second, tool-based guardrails: linters, static analysis, and automated test suites that provide continuous feedback so the agent can self-correct whenever a check fails. Third, file-based &amp;ldquo;keyframing&amp;rdquo;: creating empty skeleton files with the right namespaces and naming conventions upfront so the AI writes code that fits the existing structure instead of inventing random files.&lt;/p&gt;
&lt;p&gt;Using these techniques, his team shipped an entire contract-management feature spanning multiple applications and repositories in minutes rather than hours. Kießling even had the AI build a Python monitoring tool from scratch in a few hours despite having limited Python experience himself, thanks to thorough requirements docs and automated guardrails. The lesson: upfront planning matters more than ever—AI can execute almost anything, and experienced engineers are there to make sure it builds the right thing.&lt;/p&gt;
&lt;h2 id="jep-483-ahead-of-time-class-loading--linking"&gt;&lt;a href="https://www.morling.dev/blog/jep-483-aot-class-loading-linking/" rel="noopener noreferrer"&gt;JEP 483: Ahead-of-Time Class Loading &amp;amp; Linking&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gunnar Morling puts JEP 483—a Java 24 feature from Project Leyden—to the test, showing how it cuts Java application startup time without requiring any source code changes. The idea is shifting class loading and linking from runtime to build time, building on top of existing Application Class Data Sharing (AppCDS) machinery. Creating the AOT cache takes a two-step training run: first recording loaded classes into a configuration file, then generating the cache image from that configuration, with the classpath kept identical between training and production runs.&lt;/p&gt;
&lt;p&gt;On Apache Kafka 4.0, the resulting AOT cache file weighs around 66 MB and drops startup time from 690 ms to 285 ms—a 59% reduction—with most of the savings coming from skipping class reading and parsing. On Apache Flink, time to first message drops from 1.875 seconds to 0.913 seconds, a 51% improvement. Some limitations remain: custom class loaders are not yet supported, JVM startup flags must be adjusted, and integrating the training run into container image builds can add pipeline complexity. Compared with GraalVM native images—which start in milliseconds and use less memory but require code adjustments and a closed-world assumption—Project Leyden aims for a pragmatic middle ground that is immediately useful for cloud-native Java services.&lt;/p&gt;
&lt;h2 id="specifications-in-jakarta-data"&gt;&lt;a href="https://in.relation.to/2025/03/28/repository-specifications/" rel="noopener noreferrer"&gt;Specifications in Jakarta Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin King (Hibernate) shows how to implement the &amp;ldquo;specifications&amp;rdquo; pattern—familiar from Spring Data—on top of Jakarta Data. Specifications allow dynamic query filtering via the JPA Criteria API without repetitive boilerplate. While Jakarta Data does not yet include built-in specification support, King demonstrates that all it takes is a shared super-interface &lt;code&gt;JpaRepository&amp;lt;T&amp;gt;&lt;/code&gt; exposing two methods: &lt;code&gt;session()&lt;/code&gt; returning Hibernate&amp;rsquo;s &lt;code&gt;StatelessSession&lt;/code&gt; and &lt;code&gt;entityClass()&lt;/code&gt; returning the entity class. Built on top of those, &lt;code&gt;find()&lt;/code&gt; and &lt;code&gt;count()&lt;/code&gt; accept a specification modeled as a &lt;code&gt;BiFunction&amp;lt;CriteriaBuilder, Root&amp;lt;T&amp;gt;, Predicate&amp;gt;&lt;/code&gt; and construct the corresponding Criteria query.&lt;/p&gt;
&lt;p&gt;Paired with the JPA static metamodel, this approach is fully type-safe, catching misspelled attribute names or type mismatches at compile time. King also includes a &lt;code&gt;compose()&lt;/code&gt; helper for combining multiple specifications and hints that Jakarta Data 1.1 is working on a &amp;ldquo;much more interesting&amp;rdquo; native solution. The two snippets below count books matching a title pattern and find books matching both title and author name:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;count&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;find&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;and&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;authors&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Author_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;equalTo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;authorName&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;toLowerCase&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="there-is-no-vibe-engineering"&gt;&lt;a href="https://serce.me/posts/2025-03-31-there-is-no-vibe-engineering" rel="noopener noreferrer"&gt;There is no Vibe Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov (SerCe) contrasts &amp;ldquo;vibe coding&amp;rdquo;—Andrej Karpathy&amp;rsquo;s term for programming primarily via AI prompts rather than working directly with code—with real software engineering. His central thesis builds on the classic definition that &amp;ldquo;software engineering is programming integrated over time&amp;rdquo;: vibe coding solves for a single point in time, whereas production systems must survive real-world traffic, scale with demand, withstand security threats, migrate live user data, and adapt to changing requirements. AI can spin up prototypes remarkably fast, but these long-term concerns are hard to express in a prompt and impossible to verify just by eyeballing the UI. Good engineering practices push failure modes left, where fixing them is cheap; vibe coding pushes them right, where fixing them is expensive.&lt;/p&gt;
&lt;p&gt;Tselovalnikov imagines a future where &amp;ldquo;vibe engineering&amp;rdquo; could exist: systems assembled from strictly encapsulated AI-generated components surrounded by rigorous automated testing, profiling, tracing, canary deployments, and protocol compatibility checks. In that world, the engineer&amp;rsquo;s role blends software architect and platform engineer—writing less application code by hand while spending far more energy on boundaries and verification. Yet that is still traditional software engineering, just operating with new tools. In his view, the true inflection point will only arrive when engineers feel comfortable going on call for a production service written entirely by AI—something very few would dare do today.&lt;/p&gt;
&lt;h2 id="refining-var-handles-in-valhalla"&gt;&lt;a href="https://cr.openjdk.org/~jrose/values/atomic-value-access-api.html" rel="noopener noreferrer"&gt;Refining Var-Handles in Valhalla&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This technical design note by John Rose (OpenJDK) explores how &lt;code&gt;VarHandle&lt;/code&gt;—Java&amp;rsquo;s API for heap variable access supporting &lt;code&gt;getfield&lt;/code&gt;, &lt;code&gt;putfield&lt;/code&gt;, and atomic operations like CAS—needs to evolve to support value types in Project Valhalla. The core challenge is ensuring the interpreter, JIT compiler, and JNI access memory consistently when a variable can be laid out in multiple physical representations on the heap. The &lt;code&gt;LayoutKind&lt;/code&gt; enum defines six representations: &lt;code&gt;REFERENCE&lt;/code&gt; for traditional nullable managed pointers, &lt;code&gt;ATOMIC_FLAT&lt;/code&gt; for values packed into 64 bits, &lt;code&gt;NON_ATOMIC_FLAT&lt;/code&gt; for multi-field values wider than 64 bits, their nullable counterparts &lt;code&gt;NULLABLE_ATOMIC_FLAT&lt;/code&gt; and &lt;code&gt;NULLABLE_NON_ATOMIC_FLAT&lt;/code&gt; (which include a null indicator), and &lt;code&gt;BUFFERED&lt;/code&gt; for read-only heap-buffered copies.&lt;/p&gt;
&lt;p&gt;Rose proposes retiring the current internal &lt;code&gt;getValue&lt;/code&gt; method as insufficient, replacing it with three metadata queries and one new access primitive: &lt;code&gt;isFlat()&lt;/code&gt; to distinguish flattened values from ordinary references, &lt;code&gt;isConsistent()&lt;/code&gt; to indicate whether reads and writes are strictly atomic (non-tearing), &lt;code&gt;isPortableAtomic()&lt;/code&gt; to indicate support for advanced atomic operations like CAS, and &lt;code&gt;copyConsistentValue()&lt;/code&gt; to atomically copy heap words according to the layout&amp;rsquo;s protocol. The key design insight is splitting responsibilities into two layers: a new low-level intrinsic handles atomic memory copying, while existing &lt;code&gt;Unsafe&lt;/code&gt; methods operate on a thread-local buffer (specifically a one-element array) to pack and unpack value fields. This keeps &lt;code&gt;VarHandle&lt;/code&gt; logic clean and decoupled from complex GC and memory-layout details.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>MiTi Ranks AI Coding Agents</title><link>https://miti99.com/en/post/2025/05/01/</link><pubDate>Thu, 01 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/01/</guid><description>&lt;p&gt;&lt;em&gt;This is purely my personal opinion. I mostly use AI Agents for small personal side projects, so my experience might not be universally accurate. This post is just to share my perspective.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2025/05/01/img/tierlist.png" alt="Tierlist"&gt;&lt;/p&gt;
&lt;h2 id="explanation"&gt;Explanation&lt;/h2&gt;&lt;h3 id="augment"&gt;Augment&lt;/h3&gt;&lt;p&gt;Augment has a pretty solid codebase auto-indexing mechanism, and right now Augment is offering &lt;strong&gt;unlimited&lt;/strong&gt; usage on its Developer plan, which is a great bargain at $30 (I&amp;rsquo;m a big fan of &amp;ldquo;unlimited&amp;rdquo; plans, even knowing full well that nothing is ever truly unlimited :D).&lt;/p&gt;
&lt;p&gt;Update 7/5/2025: Augment updated its pricing to a hefty $50/month with a cap of 600 messages/month (around 20 messages/day). Suddenly Augment doesn&amp;rsquo;t look quite as amazing to me anymore :D&lt;/p&gt;
&lt;h3 id="cursor--windsurf"&gt;Cursor &amp;amp; Windsurf&lt;/h3&gt;&lt;p&gt;Both of these tools are quite solid. Cursor initially felt significantly ahead, but in recent releases Windsurf has made notable improvements. Plus, OpenAI has acquired Windsurf, so Windsurf might get even better in the future.&lt;/p&gt;
&lt;p&gt;In terms of pricing, Cursor allows unlimited &amp;ldquo;slow premium requests&amp;rdquo;, which is pretty appealing. Windsurf holds its own with a more attractive starting price of $15 compared to Cursor ($20), though Windsurf caps you at 500 prompt credits/month.&lt;/p&gt;
&lt;h3 id="junie"&gt;Junie&lt;/h3&gt;&lt;p&gt;In its early days after launch, Junie still has plenty of room for improvement. Personally, I found Junie&amp;rsquo;s indexing rather slow, and when asked a question it sometimes has to re-read entire files, which wastes a lot of time.&lt;/p&gt;
&lt;h3 id="trae--github-copilot"&gt;Trae &amp;amp; GitHub Copilot&lt;/h3&gt;&lt;p&gt;In my experience, neither of these tools can reliably find the right files on their own—both require us to manually include files in context. However, Trae is free while Copilot is paid, so Trae gets rank C and Copilot gets rank D.&lt;/p&gt;
&lt;p&gt;GitHub Copilot is pretty slow, and it lacks (or at least I couldn&amp;rsquo;t find) an option to let Copilot run commands automatically (like an auto or brave mode), requiring manual execution instead. Obviously that&amp;rsquo;s safer from a security standpoint, but it slows down the workflow. Imagine instead of firing off a prompt, walking away to make a cup of coffee, and coming back to review the finished work, you have to sit there babysitting the agent to see if it asks to run a command so you can click approve. On top of that, every now and then Copilot gets stuck running a command forever and hangs completely, forcing me to start over from scratch—super annoying.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;p&gt;I also came across an article with a tier list covering many more tools if you want to check it out:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.pragmaticcoders.com/resources/ai-developer-tools" rel="noopener noreferrer"&gt;Best AI for coding in 2025: 25 developer tools to use (or avoid)&lt;/a&gt;
&lt;a href="https://github.com/e2b-dev/awesome-ai-agents" rel="noopener noreferrer"&gt;Awesome AI Agents&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="update-245"&gt;Update 24/5&lt;/h2&gt;&lt;p&gt;Recently, on May 15, Windsurf launched its own in-house SWE model and made the lite model free for unlimited use. For a limited time, they&amp;rsquo;re even letting users use the standard version without limits. I find it pretty compelling and well worth a try.&lt;/p&gt;
&lt;p&gt;Claude 4 was also just released on May 22. Right now Cursor, Trae, and Copilot already support it, while Windsurf and Junie don&amp;rsquo;t yet. That said, although Trae lets you use it, the queue is super long—even for Claude 3.7. On Trae, Claude 3.5 is the only one that responds quickly with minimal waiting.&lt;/p&gt;
&lt;p&gt;Also, as you know, I use AI Agents to help put together my Newsletter series. Testing Copilot with Claude 4 today produced pretty poor results—it left way too many English terms untranslated. You can check the initial commit of Newsletter #28 on GitHub to see what I mean.&lt;/p&gt;
&lt;p&gt;My current priority ranking is: Windsurf &amp;gt; Cursor &amp;gt; Trae &amp;gt; Junie &amp;gt; Copilot. Trae ranks that high simply because it&amp;rsquo;s free. I&amp;rsquo;ve stopped using Augment since my trial ended and the new pricing is too steep—as much as I liked it before, when it hits the wallet I have to let it go. Soon I&amp;rsquo;ll also stop using Junie, and then Copilot after that, once my trials expire, since neither feels worth paying for. If I do open my wallet, I&amp;rsquo;ll invest in Windsurf or Cursor.&lt;/p&gt;</description></item></channel></rss>