<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>AI Coding on miti99</title><link>https://miti99.com/en/tags/ai-coding/</link><description>Recent content in AI Coding 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-coding/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #128</title><link>https://miti99.com/en/post/2026/08/28/</link><pubDate>Fri, 28 Aug 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/08/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #128.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="some-new-agentic-patterns"&gt;&lt;a href="https://blog.fsck.com/2026/07/05/new-patterns/" rel="noopener noreferrer"&gt;Some new agentic patterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jesse Vincent, creator of the open-source agent SDK Lace, shares the new patterns his company Prime Radiant uses to integrate AI agents into daily workflows. Rather than waiting to be prompted, these agents work proactively right inside Slack: Scribble monitors emerging issues and autonomously updates internal documentation, Nora supports go-to-market efforts and suggests opportunities like conferences worth submitting talks to, and Sen is a suite of personal assistant agents handling email triage, scheduling, and research.
The standout pattern is what the author calls &amp;ldquo;agentic user in the loop&amp;rdquo;: while developing Sen 2.0, Claude Code worked directly with another agent named Ada-sen without a human relaying messages between them. Claude proposed changes, Ada read the spec, asked clarifying questions, ran live tests, and gave feedback, with the two iterating back and forth—sometimes shipping entire features overnight. For security, the architecture relies on privilege separation: the primary agent cannot make arbitrary outbound connections, credentials live in 1Password and are injected into requests only through an authenticating proxy, and any subagent that needs them must request approval from a &amp;ldquo;judge&amp;rdquo; agent, keeping secrets out of conversation transcripts. Even so, Vincent acknowledges that Simon Willison&amp;rsquo;s &amp;ldquo;Lethal Trifecta&amp;rdquo;—an agent that can read private data, communicate externally, and ingest untrusted content—remains an ever-present risk requiring careful mitigation.&lt;/p&gt;
&lt;h2 id="why-i-stopped-arguing-with-people"&gt;&lt;a href="https://wangcong.org/2026-06-30-why-i-stopped-arguing-with-people.html" rel="noopener noreferrer"&gt;Why I Stopped Arguing With People&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Software engineer Cong Wang reflects on his evolution from loving technical debates to prove he was right, to realizing that most arguments achieve nothing. Drawing from Laozi&amp;rsquo;s &lt;em&gt;Tao Te Ching&lt;/em&gt;—where &amp;ldquo;being&amp;rdquo; and &amp;ldquo;non-being&amp;rdquo; give rise to each other—he notes that for someone to be right, someone else must be cast as clearly wrong. Winning an argument creates a loser, making the victory hollow. In his view, most arguments defend egos rather than ideas: once the other person feels personally attacked, they dig in, and the sharper your logic, the harder their position calcifies.&lt;/p&gt;
&lt;p&gt;Wang points out that humans feel first and rationalize second, leaving pure logic powerless against emotionally rooted beliefs. People rarely learn from unsolicited advice; they learn from consequences, and correcting others usually breeds resentment. The only exception is when someone actively asks for help—only then do their defenses drop so real learning can happen. Instead of trying to win debates, he suggests treating disagreement as a competitive advantage, since business opportunities often lie precisely where consensus hasn&amp;rsquo;t formed yet. Ultimately, the only person you can change is yourself, by humbly seeking feedback and genuinely taking it to heart.&lt;/p&gt;
&lt;h2 id="understanding-is-the-new-bottleneck"&gt;&lt;a href="https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html" rel="noopener noreferrer"&gt;Understanding is the new bottleneck&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his July 2026 AI Engineer talk, Notion design engineer Geoffrey Litt argues that as AI agents generate more and more code, the primary bottleneck is no longer typing speed—it is human understanding. According to Litt, understanding the codebase isn&amp;rsquo;t mainly about catching agent mistakes (which agents are increasingly good at verifying themselves), but about maintaining enough mental fluency in the system to keep contributing good ideas across dozens of iterative rounds with the agent. Skipping comprehension accumulates &amp;ldquo;cognitive debt&amp;rdquo; that compounds painfully over time.&lt;/p&gt;
&lt;p&gt;Litt highlights three techniques to address this. First, rich code walkthroughs: his custom &lt;code&gt;/explain-diff&lt;/code&gt; skill generates explanations that lead with background context, intuition before low-level details, and interactive diagrams, paired with comprehension quiz questions that act as a &amp;ldquo;speed bump&amp;rdquo; forcing the author to truly understand the change before sharing it. Second, &amp;ldquo;micro-worlds,&amp;rdquo; inspired by educator Seymour Papert&amp;rsquo;s idea of &amp;ldquo;living in Mathland&amp;rdquo;: having agents spin up small custom interactive environments—like visual debuggers, dashboards, or simulations—so humans can explore and build intuition about how the system behaves. Third, shared workspaces where agents plan alongside humans on collaborative docs so the whole team thinks together rather than in isolated silos. He closes with Alan Kay&amp;rsquo;s 50-year-old vision: computers exist to augment human intellect, not merely to automate tasks away.&lt;/p&gt;
&lt;h2 id="when-to-repeat-yourself"&gt;&lt;a href="https://newsletter.francofernando.com/p/when-to-repeat-yourself" rel="noopener noreferrer"&gt;When to repeat yourself&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Franco Fernando revisits the DRY (Don&amp;rsquo;t Repeat Yourself) principle, arguing that deduplicating code carries hidden costs many engineers overlook. The biggest is the &amp;ldquo;coordination tax&amp;rdquo;: when multiple teams share a module, every change requires alignment meetings, design reviews, and merge negotiations, whereas a team modifying its own local copy can move immediately. The real question, then, is whether coordinating a shared abstraction costs more than letting separate copies drift apart. Fernando distinguishes &lt;em&gt;incidental duplication&lt;/em&gt;—code that looks similar today but belongs to different business domains and will evolve in different directions—from &lt;em&gt;essential duplication&lt;/em&gt;, where the exact same business rule is repeated in multiple places; only the latter belongs in a shared abstraction.&lt;/p&gt;
&lt;p&gt;He advises patience, because waiting for clarity is cheap while premature abstraction is expensive. Every code-sharing mechanism comes with trade-offs: shared libraries are easy to extract but create transitive dependency and versioning headaches; microservices offer clean API contracts but add network latency, operational overhead, and availability risks; inheritance breeds rigid hierarchies, while composition is more flexible at the cost of extra wiring. His rule of thumb: within a single team&amp;rsquo;s boundary, DRY usually wins, but across organizational boundaries you should recalculate the trade-off and favor reversible choices—because merging duplicated code later is far easier than untangling a tightly coupled abstraction.&lt;/p&gt;
&lt;h2 id="let-ai-burn"&gt;&lt;a href="https://www.wheresyoured.at/let-ai-burn/" rel="noopener noreferrer"&gt;Let AI Burn&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ed Zitron argues that the AI industry is a bubble built on hype and circular financing, and if it bursts, the government should not bail it out. In his view, the situation bears no resemblance to 2008: banks were vital economic infrastructure, whereas AI companies are not, and aside from SoftBank lending over $40 billion to OpenAI, there is no comparable systemic contagion risk. In 2026 alone, OpenAI and Anthropic raised over $300 billion while continuing to post massive losses; those two companies account for 89% of revenue among top AI startups, while the rest of the sector generates roughly $20 billion a year combined.
Zitron also rejects the familiar dot-com bubble analogy: overbuilt fiber-optic cables remained useful for decades, whereas GPUs are narrow-purpose assets that depreciate rapidly. Hyperscalers are projected to spend $765 billion in capex in 2026 and over $1 trillion in 2027, with OpenAI alone burning roughly $50 billion on compute this year. He dismisses Sam Altman&amp;rsquo;s proposal to give the US government a 5% equity stake worth $42 billion, noting that figure wouldn&amp;rsquo;t even cover a single year of compute spend and does nothing to fix underlying unprofitability. His conclusion: let the market clear itself, because any bailout would require endless capital injections with no exit in sight.&lt;/p&gt;
&lt;h2 id="when-ai-costs-more-than-the-engineer"&gt;&lt;a href="https://tomtunguz.com/ai-spend-breakeven-2029/" rel="noopener noreferrer"&gt;When AI Costs More Than the Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz points out a striking inversion in software economics: at leading AI-native companies, compute spend per employee has surpassed compensation. Anthropic spends roughly $2 million per employee annually on compute—2.3 times its fully burdened compensation cost of around $500,000 per head. In return, revenue per employee reaches $14 million at Anthropic and $6.5 million at OpenAI, the highest in the world and far above the $250,000–$600,000 typical of traditional SaaS companies.&lt;/p&gt;
&lt;p&gt;The rest of the market is still far behind. The top 1% of software companies spend roughly $89,000 per engineer per year on AI—about 40% of a $224,000 salary—while the median company spends just $137. Tunguz models three scenarios for 2029: a low case of $106,000 per engineer (41% of salary), a base case of $363,000 (140%), and a high case of $596,000 (230%), matching Anthropic&amp;rsquo;s ratio today. Where the market lands depends on two opposing forces. On one side, token prices have fallen roughly 10x per year for the past three years, open-weight models are narrowing the quality gap at lower cost, and enterprises can cap usage by role. On the other side, frontier model pricing holds steady while agentic workflows consume vastly more tokens—to the point that Goldman Sachs projects token consumption will grow 24x by 2030.&lt;/p&gt;
&lt;h2 id="the-best-code-is-the-one-you-shiftdelete"&gt;&lt;a href="https://ayende.com/blog/204067-a/the-best-code-is-the-one-you-shift-delete/" rel="noopener noreferrer"&gt;The best code is the one you shift+delete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;RavenDB creator Oren Eini argues that measuring coding models by how fast they write production code misses the point; their real superpower is making previously impractical, throwaway work effortless. He recounts debugging a production incident involving 25–30 MB of compressed logs. Finding individual errors was easy, but correlating events across a timeline was hard, and feeding the entire log into an LLM was both impractical and expensive. Instead, he pasted the first ten lines and asked the model to write a script to extract, aggregate, and tabulate the events; in under a minute he had a tool he could iterate on, such as plotting index changes over time. The root cause jumped out immediately: the customer was running multiple application versions, each with its own index definitions, continuously overwriting one another. Eini never read a line of the script and deleted it as soon as the bug was found.&lt;/p&gt;
&lt;p&gt;His second example is the polar opposite: refactoring query execution in Corax, core engine code meant to live in the product for decades. Here the model typed while Eini steered and reviewed every line. He warns that after hours of trying, reverting, and retrying approaches, it is all too easy to look up and find two thousand lines of diff you don&amp;rsquo;t truly own. To retain authorship and confidence, he relies on existing regression tests for old behavior, new tests for new behavior, and a disposable test harness that runs the old and new implementations side-by-side and visualizes the results. Building temporary scaffolding like that used to take hours or weeks; now it takes minutes.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Articles:&lt;/strong&gt;
&lt;a href="https://zalo.me/vi/founder" rel="noopener noreferrer"&gt;Chia sẻ suy nghĩ về sản phẩm và người làm sản phẩm&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;Vuong Quang Khai, founder of Zalo, shares his perspective on product building: the three universal product values are usefulness, aesthetics, and intuitiveness, to which Zalo adds simplicity, reliability, and privacy—and the hardest part of the craft is making trade-offs when good values conflict. In product builders, he prizes three qualities above all: deep user empathy, the courage to make tough trade-offs, and obsession with small details, while expressing skepticism toward purely data-driven decision-making or A/B testing and emphasizing that, above all, you must genuinely love the product you build.&lt;/p&gt;

&lt;/blockquote&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 #108</title><link>https://miti99.com/en/post/2026/06/04/</link><pubDate>Thu, 04 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #108.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-is-solved-software-is-not"&gt;&lt;a href="https://arcplane.ai/journal/software-is-not-solved" rel="noopener noreferrer"&gt;Coding is solved? Software is not.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Opening with Boris Cherny&amp;rsquo;s (creator of Claude Code) remark that coding is &amp;ldquo;basically solved,&amp;rdquo; Arcplane&amp;rsquo;s Gao argues that the statement is true but incomplete. Coding is merely translating instructions into source code, whereas software development is turning ambiguous intent into a reliable system — a process of progressively reducing entropy. The paradox is that fast AI code generation can actually increase entropy: massive test suites that only validate whatever implementation the agent happened to pick, and plausible-sounding plans that leave core product decisions unresolved. Code arrives sooner, but the team doesn&amp;rsquo;t reach confidence any sooner — the bottleneck simply shifts to review, reconstructing the agent&amp;rsquo;s intent, and interpreting noisy verification evidence.&lt;/p&gt;
&lt;p&gt;Drawing on experience running an authentication product managing millions of identities, the author points to four things that need to change. First, context must be curated deliberately, and review feedback must be captured for future runs. Second, specifications must live alongside the work and be updated as new edge cases surface, because an agent will happily build a complete implementation of an ambiguous requirement. Third, verification evidence must be clear enough for a reviewer to see what the agent ran, what failed, and how it fixed it. Fourth, humans need well-placed checkpoints — especially before deployment — because &amp;ldquo;clean code cannot save a bad spec,&amp;rdquo; and review depth should scale with risk.&lt;/p&gt;
&lt;h2 id="ideas"&gt;&lt;a href="https://www.noahzender.com/ideas" rel="noopener noreferrer"&gt;Ideas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rather than a single essay, this is Noah Zender&amp;rsquo;s index page collecting nearly 500 mental models, patterns, and frameworks distilled from hundreds of books, podcasts, and videos. The ideas are organized into 11 categories: mental models and decision-making, knowledge and learning, creativity and writing, product and startups, brand and marketing, tech innovation and AI, investing and economics, psychology and self-improvement, work and leadership, philosophy and worldview, plus an uncategorized bucket. Each entry links to a short standalone page, reading more like a personal knowledge base than a linear article.&lt;/p&gt;
&lt;p&gt;A representative example is the &amp;ldquo;Leveraged Expert&amp;rdquo; concept, which argues that &lt;em&gt;when&lt;/em&gt; you specialize matters just as much as &lt;em&gt;what&lt;/em&gt; you specialize in. Every technology adoption curve has an inflection point where growth either crosses into the mainstream or rapidly fizzles out. If you are already an expert in a field right as it hits that inflection point, your leverage compounds automatically as adoption takes off without requiring extra effort on your part. Specializing too early in a field that is still too nascent yields much lower leverage; the sweet spot is the early-adopter phase, where the surface area for luck is highest. For younger developers, it&amp;rsquo;s a useful lens when deciding which technologies to invest in deeply.&lt;/p&gt;
&lt;h2 id="ai-productivity-debate"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-productivity-debate" rel="noopener noreferrer"&gt;AI productivity debate&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from DX&amp;rsquo;s Engineering Enablement newsletter recaps the closing panel of the DX Annual conference, featuring engineering leaders and researchers from Etsy, Twilio, GitHub, Google, and DX. Asked whether AI will mean needing fewer engineers, most panelists disagreed: demand for software rises as the cost of building it falls, so total builder headcount won&amp;rsquo;t shrink even if the definition of an engineer evolves. On technical debt, opinions split: Twilio&amp;rsquo;s representative viewed AI as an amplifier (garbage in, garbage out), while Brian Houck warned that organizations are optimizing for PR velocity over simplicity, accumulating &amp;ldquo;comprehension debt&amp;rdquo; as humans understand less and less of a codebase largely written by AI.&lt;/p&gt;
&lt;p&gt;The panelists opposed top-down AI mandates: Twilio simply pre-installed tools and offered basic guidance yet still saw adoption surge, whereas mandates tend to breed superficial compliance. Using AI utilization as an individual performance metric was roundly rejected by engineers. As for bottlenecks, developers spend only about 14% of their time writing code, so the real constraints remain decision-making, prioritization, and product design; code review mostly feels slower because code is being generated faster. Finally, most adoption hurdles are human and cultural: leaders need to give engineers dedicated time to learn, and two-week group learning sprints proved far more effective than isolated solo tinkering.&lt;/p&gt;
&lt;h2 id="maintainability-sensors-for-coding-agents"&gt;&lt;a href="https://martinfowler.com/articles/sensors-for-coding-agents.html" rel="noopener noreferrer"&gt;Maintainability sensors for coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) shares hands-on experiments with maintainability &amp;ldquo;sensors&amp;rdquo; that help both humans and AI coding agents gauge code quality, building on the concept of &amp;ldquo;harness engineering.&amp;rdquo; Her testbed was a TypeScript, Next.js, and React dashboard rebuilt entirely with AI and given almost no up-front code-quality instructions, designed to see how far an agent could get relying solely on feedback from sensors like the type checker, ESLint, Semgrep, &lt;code&gt;dependency-cruiser&lt;/code&gt;, the test suite, and mutation testing. With ESLint, she enabled rules capping parameter counts, file length, function length, and cyclomatic complexity, rewriting error messages into actionable remediation instructions and allowing the agent to suppress warnings only if it attached an explicit justification for reviewers.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;dependency-cruiser&lt;/code&gt; helped the agent respect layered module boundaries and self-correct violations. Raw coupling metrics, by contrast, proved noisy and poorly interpreted by AI because &amp;ldquo;good&amp;rdquo; versus &amp;ldquo;bad&amp;rdquo; coupling depends heavily on context — whereas an AI modularity review guided by a strong prompt caught valuable issues like duplicated route logic and misplaced responsibilities. For AI-generated tests, high line coverage did not guarantee quality: some files hit 100% statement coverage without a single true unit test, and only mutation testing exposed the missing assertions. Böckeler concludes that computational sensors work best at the file and function level, while cross-module design issues require AI to supply semantic interpretation. Sensors boost confidence in agent output, but they still cannot replace human judgment.&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 #105</title><link>https://miti99.com/en/post/2026/05/27/</link><pubDate>Wed, 27 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/27/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #105.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="virtual-memory-a-deep-dive-into-page-tables-tlbs-and-linux-internals"&gt;&lt;a href="https://blog.codingconfessions.com/p/virtual-memory" rel="noopener noreferrer"&gt;Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abhinav Upadhyay (of the blog &lt;em&gt;Confessions of a Code Addict&lt;/em&gt;) wrote a massive ~25,000-word deep dive explaining virtual memory on x86-64 Linux from first principles down to kernel implementation details. Framed as a dialogue between a process named &amp;ldquo;Alloca&amp;rdquo; and the &amp;ldquo;Kernel,&amp;rdquo; each question from Alloca unlocks a new concept, guiding the reader naturally from &amp;ldquo;why do we need virtual memory?&amp;rdquo; (process isolation, memory protection, the illusion of abundant memory) to the underlying mechanisms. Each process gets a 128 TiB user-space half of the 48-bit virtual address space, divided into text, data, BSS, heap, memory-mapped, and stack segments.&lt;/p&gt;
&lt;p&gt;The centerpiece is the address translation journey: the CR3 register points to a four-level page table (PGD, PUD, PMD, PTE), where each level consumes 9 bits of the address and the final 12 bits index into a 4 KB page. Because walking four levels on every memory access would be prohibitively slow, the TLB (Translation Lookaside Buffer) caches translations, making TLB hit rate a direct driver of application performance. The article then covers demand paging (allocating physical frames only on first access, distinguishing minor faults that require no I/O from major faults that must read from disk), copy-on-write after &lt;code&gt;fork()&lt;/code&gt; (parent and child share read-only frames and only copy on write), &lt;code&gt;mmap()&lt;/code&gt; mapping files through the page cache to skip &lt;code&gt;read()&lt;/code&gt;&amp;rsquo;s extra copy, and how the MMU enforces permissions via page table bits, including the NX bit used for W^X protection.&lt;/p&gt;
&lt;h2 id="orchestrating-ai-code-review-at-scale"&gt;&lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;Orchestrating AI Code Review at scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares how they brought AI code review into CI across their entire engineering organization, using OpenCode to orchestrate multiple specialized agents rather than asking a single giant model to inspect everything. Each merge request can be evaluated by up to seven domain-specific agents covering security, performance, code quality, documentation, release management, and compliance; an orchestrator agent aggregates the findings, deduplicates them, and makes the final call. Each agent&amp;rsquo;s prompt is narrowly scoped and explicitly lists &amp;ldquo;what NOT to flag&amp;rdquo; to keep noise down. A plugin architecture behind a &lt;code&gt;ReviewPlugin&lt;/code&gt; interface decouples version control systems, AI providers, and internal standards, avoiding vendor lock-in.&lt;/p&gt;
&lt;p&gt;To balance cost and quality, the system tiers its models: frontier models (Claude Opus 4.7, GPT-5.4) handle orchestration only, standard models (Claude Sonnet 4.6, GPT-5.3) do the bulk of the reviewing, and lightweight models handle text-heavy tasks like documentation. Merge requests are triaged by risk into trivial, lite, or full, so minor edits don&amp;rsquo;t spin up all seven agents while security-sensitive files always receive a full review. Circuit breakers, timeouts, and a control plane running on Cloudflare Workers keep the system resilient. In its first 30 days, the system ran 131,246 reviews at an average cost of $1.19 per review and an 85.7% cache hit rate.&lt;/p&gt;
&lt;h2 id="the-8-levels-of-agentic-engineering"&gt;&lt;a href="https://www.bassimeledath.com/blog/levels-of-agentic-engineering" rel="noopener noreferrer"&gt;The 8 Levels of Agentic Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bassim Eledath proposes an eight-level framework describing how development teams progressively get more leverage out of AI in software engineering, starting from the observation that &amp;ldquo;AI&amp;rsquo;s coding ability is outpacing our ability to harness it.&amp;rdquo; Levels 1 and 2 are autocomplete and AI-first IDEs like Cursor; Level 3 is context engineering, optimizing every token fed into the model; Level 4 is compounding engineering, with a loop of planning, delegating, evaluating, and recording lessons so each session improves on the last; Level 5 uses MCP and skills to connect databases, APIs, and CI; Level 6 is harness engineering, building environments with automated feedback loops so agents can self-correct; Level 7 is asynchronous background agents; and Level 8 is autonomous agent teams coordinating directly without a central orchestrator — an early, still-challenging frontier.&lt;/p&gt;
&lt;p&gt;The author highlights several cross-cutting lessons. A &amp;ldquo;multiplayer&amp;rdquo; effect means an individual&amp;rsquo;s productivity depends heavily on their teammates&amp;rsquo; level: a Level 7 engineer is still bottlenecked if colleagues manually review PRs at Level 2. Giving agents constraints works better than giving step-by-step instructions, because agents tend to follow instructions rigidly while missing unstated requirements. Finally, using different models for different roles yields better overall results, and the implementing model should never review its own output to avoid self-preference bias.&lt;/p&gt;
&lt;h2 id="hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away"&gt;&lt;a href="https://dev.to/bing_yu/hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away-4dln" rel="noopener noreferrer"&gt;Hexagonal Architecture is Not a Layered Architecture: Topology, Safety, and When to Walk Away&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article points out that the core difference between hexagonal architecture and layered architecture lies in the direction of dependencies rather than complexity. Layered architecture lets dependencies flow vertically down a chain of controller, service, and repository; in hexagonal architecture, dependencies point inward toward the center: adapters depend on ports, ports belong to the domain, and business logic has no idea what implements an outbound port. Alistair Cockburn&amp;rsquo;s original 2005 model split ports into driving and driven sides while allowing multiple ports by communication purpose; many modern implementations influenced by Clean Architecture add concentric inner rings, and each ring adds data-mapping overhead that wasn&amp;rsquo;t part of the original design.&lt;/p&gt;
&lt;p&gt;Port ownership matters too: in the author&amp;rsquo;s chosen layout, Inbound Ports belong to the application layer while Outbound Ports belong to the domain layer, and keeping that distinction clear helps tell whether a change reflects a shift in business requirements or merely a swapped implementation. Adapters handle protocol translation and structural validation like JSON syntax or field types, whereas the domain handles semantic validation like business invariants; if a rule still holds after swapping out the underlying technology, it belongs in the domain. The author is also candid that hexagonal architecture does not automatically give you deployment isolation, input sanitization, or security hardening, and for a CRUD system with 3 controllers, 5 services, and 2 tables, its indirection is a concrete tax paid for abstract benefits; the payoff only grows as complexity grows.&lt;/p&gt;
&lt;h2 id="spec-driven-development-how-ai-coding-moves-beyond-vibe-coding"&gt;&lt;a href="https://www.vitaliihonchar.com/insights/spec-driven-development" rel="noopener noreferrer"&gt;Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitalii Honchar introduces spec-driven development as the next step beyond &amp;ldquo;vibe coding&amp;rdquo;: instead of steering AI through an endless series of small conversational nudges, the developer writes a detailed technical specification up front and lets the AI implement from it autonomously. The workflow follows four sequential stages: co-author a requirements specification in Markdown with the AI, have the AI generate an implementation plan from the spec, break the plan into small manageable tasks, and let the AI execute the whole thing with minimal intervention. The author uses GitHub Spec Kit to bootstrap projects around this workflow.&lt;/p&gt;
&lt;p&gt;Compared to vibe coding, this approach keeps the AI aligned with defined requirements, produces documentation from day one, and frees the developer to focus on other work while the AI builds. As a practical example, the author built AgentD — a local service for scheduling and running AI agents — in about five hours without writing code by hand, a project that would have taken weeks manually. In his view, software engineers should shift their focus toward architectural thinking, requirements definition, and quality verification rather than competing with AI on raw coding speed.&lt;/p&gt;
&lt;h2 id="go-vs-java-the-minimalist-vs-the-enterprise-veteran"&gt;&lt;a href="https://dev.to/adamthedeveloper/go-vs-java-the-minimalist-vs-the-enterprise-veteran-1gg3" rel="noopener noreferrer"&gt;Go vs Java: The Minimalist vs The Enterprise Veteran&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two languages built on opposite philosophies: Go embraces radical minimalism (no classes, no inheritance, and no generics until 2022), while Java offers a rich toolkit of generics, inheritance, interfaces, and annotations. According to the author, Go&amp;rsquo;s minimalism lets new team members read and understand a codebase from day one. On performance, Go compiles to native binaries that start in milliseconds, making it a natural fit for containerized workloads; Java runs on the JVM, starting slower but warming up to high peak throughput thanks to JIT compilation in long-running services.&lt;/p&gt;
&lt;p&gt;The concurrency gap has narrowed considerably: Go&amp;rsquo;s goroutines and channels have long been lightweight and ergonomic, but Virtual Threads in Java 21 now bring M:N scheduling to Java&amp;rsquo;s familiar thread API, even if the underlying mechanics and trade-offs still differ from goroutines. In terms of ecosystem, Java boasts millions of mature libraries with Spring dominating enterprise development, while Go favors quality over quantity with a standard library sufficient for most tasks. Go shines for infrastructure, CLIs, microservices, and cloud-native apps; Java excels in complex enterprise systems. The author concludes that neither language is universally superior — the right choice depends on project requirements and team expertise.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-goal"&gt;&lt;a href="https://x.com/Saboo_Shubham_/status/2054988166541770782" rel="noopener noreferrer"&gt;The ultimate guide to /goal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shubham Saboo argues that &lt;code&gt;/goal&lt;/code&gt; is not just a feature, but is emerging as a foundational primitive for coding agents, much like HTTP or JSON. With normal prompting, you steer turn by turn: read the response, evaluate it, and nudge the agent to the next step. &lt;code&gt;/goal&lt;/code&gt; flips that model: you describe what &amp;ldquo;done&amp;rdquo; looks like, send it once, and the agent loops autonomously until it gets there — for example, &amp;ldquo;build the app according to SPEC.md; done means tests pass, build passes, README is accurate, and git status is clean.&amp;rdquo; It shifts the interaction from micromanaging steps to delegating against a clear objective. Notably, three separate ecosystems — OpenAI Codex CLI, Claude Code, and the Hermes Agent orchestrator — have converged on the same command pattern, making them composable.&lt;/p&gt;
&lt;p&gt;Saboo outlines three enduring roles regardless of how tools evolve: the orchestrator that coordinates, selects workers, manages the Kanban board, and performs final verification (Hermes); the builder that takes a spec and generates code (Codex&amp;rsquo;s strength); and the reviewer that hunts for bugs in plausible-looking code (Claude Code&amp;rsquo;s strength). The golden rule is independent verification: Hermes never trusts Codex&amp;rsquo;s self-reported completion and instead runs &lt;code&gt;npm test&lt;/code&gt; and &lt;code&gt;npm run build&lt;/code&gt; itself — turning &lt;code&gt;/goal&lt;/code&gt; from a promise into a contract. Multiple goals can run in parallel, though each file should only have a single writing agent at a time to avoid conflicts.&lt;/p&gt;
&lt;h2 id="the-ai-native-developer"&gt;&lt;a href="https://newsletter.getdx.com/p/the-ai-native-developer" rel="noopener noreferrer"&gt;The AI-Native Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck presents research on how AI is reshaping the developer role, drawing on a survey of more than 1,300 developers and interviews with 22 practitioners. Developer work falls into three buckets: core tasks like coding, debugging, and testing score high across every dimension and represent the biggest opportunity for AI; cross-component debugging and environment provisioning are areas where developers want deeper AI help, though current tools still fall short; and relational work like stakeholder communication sits in the &amp;ldquo;low priority for AI&amp;rdquo; zone where developers want to retain their own voice and final accountability.&lt;/p&gt;
&lt;p&gt;The study identifies four stages of AI maturity: Skeptics, who adopt only when competitive pressure forces their hand; Explorers, who build confidence through small wins; Collaborators, who bring AI into their workflow much earlier; and Strategists, who orchestrate multiple agents in parallel, shifting from code producers to &amp;ldquo;architects of intent.&amp;rdquo; Alongside this progression sit three unresolved tensions: the learning paradox (are we becoming better engineers or just better prompt writers?), the risk of skill atrophy among junior developers, and an accountability gap when verification standards fail to keep pace with generation speed. Houck sketches three possible futures: maintaining deep craft at AI speed, focusing on orchestration and judgment, or becoming a &amp;ldquo;Clerical Coder&amp;rdquo; who rubber-stamps generated code without truly understanding it.&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 #91</title><link>https://miti99.com/en/post/2026/03/17/</link><pubDate>Tue, 17 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/17/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #91.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages"&gt;&lt;a href="https://dev.to/ganesh-kumar/how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages-42o4" rel="noopener noreferrer"&gt;How Go Slices Work Under the Hood: What Makes Them Stand Out from Other Languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slices are one of the most heavily used data structures in Go. On the surface they look like simple dynamic arrays, but under the hood every slice is just a three-word header: a pointer to an underlying array, a length (&lt;code&gt;len&lt;/code&gt;), and a capacity (&lt;code&gt;cap&lt;/code&gt;). Slicing with &lt;code&gt;[start:end]&lt;/code&gt; doesn&amp;rsquo;t copy the elements—it simply creates a new slice header pointing into the same backing array, which makes slicing very cheap. The author walks through examples printing &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; after each slice operation, and explains why a slice declared with &lt;code&gt;var s []int&lt;/code&gt; starts out as &lt;code&gt;nil&lt;/code&gt; with both &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; equal to 0.&lt;/p&gt;
&lt;p&gt;The highlight of the post is the growth algorithm inside &lt;code&gt;append&lt;/code&gt;, traced directly from the Go runtime source (&lt;code&gt;runtime/slice.go&lt;/code&gt;). When a slice runs out of capacity, Go allocates a larger backing array: if the current capacity is under 256 elements, it doubles; at 256 and above, the growth factor tapers smoothly from 2x down toward ~1.25x (prior to Go 1.18, that threshold was 1,024). When appending a batch of elements that exceeds double the old capacity, Go jumps straight to the required size and rounds up to the allocator&amp;rsquo;s size class. Because reallocation and copying are expensive, the practical takeaway is to preallocate with &lt;code&gt;make([]T, len, cap)&lt;/code&gt; whenever you know the expected size ahead of time.&lt;/p&gt;
&lt;h2 id="why-go-can"&gt;&lt;a href="https://niketpatel.com/essays/why-go-cant-try" rel="noopener noreferrer"&gt;Why Go Can&amp;rsquo;t Try&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay explains why Go has never gained a &lt;code&gt;try&lt;/code&gt; keyword like Zig or Rust, arguing that the real reason isn&amp;rsquo;t simply the Go team&amp;rsquo;s fondness for explicitness. Ironically, Zig is even more explicit than Go: a return type like &lt;code&gt;!Config&lt;/code&gt; advertises that a function can fail, and the compiler tracks every possible error and enforces exhaustive handling. Go, by contrast, lets you write &lt;code&gt;data, _ := os.ReadFile(path)&lt;/code&gt; without a peep from the compiler, so the explicitness of &lt;code&gt;if err != nil&lt;/code&gt; is largely social convention. While the Go team often argues that &lt;code&gt;try&lt;/code&gt; hides control flow across invisible exit points, the author contends that isn&amp;rsquo;t the root of the problem.&lt;/p&gt;
&lt;p&gt;The real blocker is Go&amp;rsquo;s &lt;code&gt;error&lt;/code&gt; type itself: because &lt;code&gt;error&lt;/code&gt; is just an interface with a single &lt;code&gt;Error() string&lt;/code&gt; method, the compiler has no idea which concrete errors a function can return; utilities like &lt;code&gt;errors.Is()&lt;/code&gt;, &lt;code&gt;errors.As()&lt;/code&gt;, and &lt;code&gt;fmt.Errorf(&amp;quot;%w&amp;quot;)&lt;/code&gt; are purely runtime conventions. Zig&amp;rsquo;s error sets are the exact opposite: finite, compiler-tracked, and represented as zero-overhead 16-bit integers—which means they can&amp;rsquo;t carry arbitrary runtime context, a trade-off Zig offsets with compiler-generated error return traces. Adding &lt;code&gt;try&lt;/code&gt; to Go without changing the &lt;code&gt;error&lt;/code&gt; type would be pure syntactic sugar with no exhaustiveness checking, while changing &lt;code&gt;error&lt;/code&gt; would break the entire standard library and every existing Go program. So &lt;code&gt;if err != nil&lt;/code&gt; is here to stay.&lt;/p&gt;
&lt;h2 id="the-scheduler--understanding-the-go-runtime"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-scheduler" rel="noopener noreferrer"&gt;The Scheduler — Understanding the Go Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explains the Go runtime scheduler—the component that answers &amp;ldquo;which goroutine runs next?&amp;rdquo; and multiplexes millions of goroutines onto a handful of OS threads. At its core is the GMP model: G is a goroutine, starting with a tiny 2KB stack (compared to 1–8MB for an OS thread); M is an OS thread that actually executes instructions; and P is a logical processor context holding a local run queue of up to 256 goroutines, with the number of Ps equal to &lt;code&gt;GOMAXPROCS&lt;/code&gt;. Decoupling P from M means that when an OS thread blocks in a syscall, its P can be handed off to another thread so queued goroutines keep running. Notably, there is no dedicated central scheduler thread: goroutines park themselves, enqueue themselves onto channel wait queues, and clean themselves up on exit for reuse.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;findRunnable()&lt;/code&gt; function searches for work in a specific order: garbage-collector work, then once every 61 ticks a check of the global run queue to prevent starvation, followed by the local run queue, the global run queue again, the network poller, and finally work stealing—taking half the goroutines from another P&amp;rsquo;s local queue. Threads that run out of work spin briefly looking for new work before parking, with the number of spinning threads capped. The article also covers preemption—both cooperative via function-prologue stack checks and asynchronous via &lt;code&gt;SIGURG&lt;/code&gt; signals. Because a goroutine&amp;rsquo;s saved state is tiny, switching goroutines takes just 50–100 nanoseconds, 10–40x faster than an OS thread context switch.&lt;/p&gt;
&lt;h2 id="go-string-concatenation-performance-benchmark"&gt;&lt;a href="https://www.winterjung.dev/en/string-concat-performance-benchmark-in-go/" rel="noopener noreferrer"&gt;Go String Concatenation Performance Benchmark&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author benchmarks the speed and memory footprint of Go string concatenation techniques, comparing &lt;code&gt;+&lt;/code&gt;, &lt;code&gt;+=&lt;/code&gt;, &lt;code&gt;fmt.Sprintf()&lt;/code&gt;, &lt;code&gt;fmt.Sprint()&lt;/code&gt;, &lt;code&gt;strings.Join()&lt;/code&gt;, &lt;code&gt;bytes.Buffer&lt;/code&gt;, and &lt;code&gt;strings.Builder&lt;/code&gt; (both with and without preallocating via &lt;code&gt;Grow()&lt;/code&gt;). The benchmarks cover two common scenarios: concatenating a fixed, known number of strings—such as building a cache key from a few fields—and concatenating a variable number of strings in a loop, such as assembling dynamic query conditions. All benchmark code and raw results are published so readers can reproduce them.&lt;/p&gt;
&lt;p&gt;The findings are clear: &lt;code&gt;strings.Builder&lt;/code&gt; with &lt;code&gt;Grow()&lt;/code&gt; and &lt;code&gt;strings.Join()&lt;/code&gt; are the fastest and most memory-efficient options across almost every scenario. When concatenating a small, fixed number of strings, the plain &lt;code&gt;+&lt;/code&gt; operator is completely fine, while &lt;code&gt;fmt.Sprintf()&lt;/code&gt; is significantly slower. In the 256-string loop benchmark, the top two methods take just 2.6–2.8 microseconds with a single allocation, whereas using &lt;code&gt;+=&lt;/code&gt; in a loop takes over 37 microseconds, allocates ~185KB of memory, and performs 255 allocations because every iteration creates a brand-new immutable string. The rule of thumb: for loops, reach for &lt;code&gt;strings.Builder&lt;/code&gt; or &lt;code&gt;strings.Join()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="message-passing-is-shared-mutable-state"&gt;&lt;a href="https://causality.blog/essays/message-passing-is-shared-mutable-state/" rel="noopener noreferrer"&gt;Message Passing Is Shared Mutable State&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay argues that message passing does not eliminate shared mutable state—it merely relocates it. Back in 2006, Edward Lee predicted that &amp;ldquo;shared memory vs. message passing&amp;rdquo; was a false dichotomy, because swapping locks for messages only changes the shape of concurrency bugs. Go, with its motto &amp;ldquo;share memory by communicating,&amp;rdquo; became the largest real-world test of that thesis: a 2019 study of 171 concurrency bugs across Docker, Kubernetes, etcd, gRPC, and CockroachDB found that roughly 58% of blocking bugs (goroutines hanging forever) were caused by message passing. Worse, Go&amp;rsquo;s built-in deadlock detector caught only 2 of the 21 blocking bugs tested.&lt;/p&gt;
&lt;p&gt;Under the hood, the author points out, a Go channel is literally a shared concurrent queue protected by a mutex, without separate send and receive capability endpoints—so every classic shared-state hazard has a channel equivalent: deadlocks, goroutine leaks, race conditions when multiple goroutines read from the same channel, and protocol violations like sending on a closed channel. A representative Kubernetes bug left a child goroutine blocked forever because nobody read from an unbuffered channel after a timeout; the fix was changing the buffer size to one. Even Erlang, with its strictly isolated processes, was found in academic studies to suffer from race conditions around ETS tables—shared mutable memory bolted back on for performance.&lt;/p&gt;
&lt;h2 id="things-i"&gt;&lt;a href="https://sjer.red/blog/2026/built-with-ai/" rel="noopener noreferrer"&gt;Things I&amp;rsquo;ve Done with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With roughly seven years of professional experience plus seven years of self-taught programming before that, the author traces his journey from AI skeptic to heavy adopter. Having previously ignored GitHub Copilot and dismissed Cursor as hype, he used to care deeply about clean architecture, expressive type systems, and long-term maintainability. The turning point came when he asked &lt;em&gt;why&lt;/em&gt; we care about those things: on the job, what matters is delivering business value, and code doesn&amp;rsquo;t need to be &amp;ldquo;clean&amp;rdquo; in the traditional human sense if it has thorough automated tests that allow AI agents to maintain it safely. Since October 2025, he stopped writing code by hand and now only writes prompts and reviews output.&lt;/p&gt;
&lt;p&gt;Over nine months using Cursor and Claude Code, he shipped more than a dozen personal projects: consolidating everything into a single monorepo, migrating CI to Buildkite and Bazel, building Clauderon—an orchestrator for multiple coding agents—along with Discord bots and mobile apps. At work, AI drafts design docs, builds diagnostic tools, and automates operational chores; small product-manager requests are now nearly free, leaving code review and manual QA as the main work. Still, he admits the review-heavy workflow is mentally tiring, and argues that testing and documentation have become the new bottlenecks where the industry needs better tooling.&lt;/p&gt;
&lt;h2 id="pushing-and-pulling-three-reactivity-algorithms"&gt;&lt;a href="https://jonathan-frere.com/posts/reactivity-algorithms/" rel="noopener noreferrer"&gt;Pushing and Pulling: Three Reactivity Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares three algorithms for building reactive systems—systems that automatically recompute derived values when inputs change, easiest to picture as a spreadsheet where editing one cell updates every formula that depends on it. The author evaluates them against four criteria: efficiency (computing each node at most once per update), granularity (updating only nodes that are actually affected), glitch-freedom (never exposing inconsistent intermediate states), and support for dynamic dependencies. Pure &lt;em&gt;push&lt;/em&gt; reactivity lets each node notify its dependents directly, giving fine granularity, but nodes in diamond dependencies can be recomputed multiple times and expose glitches unless the entire graph is topologically sorted. Pure &lt;em&gt;pull&lt;/em&gt; reactivity works like nested function calls: it is naturally glitch-free and supports dynamic dependencies for free, but has no idea which inputs changed without either recomputing everything or maintaining hard-to-invalidate caches.&lt;/p&gt;
&lt;p&gt;A hybrid &lt;em&gt;push–pull&lt;/em&gt; algorithm gets the best of both worlds: the push phase simply walks downstream to mark affected nodes as &amp;ldquo;dirty&amp;rdquo; and records which output nodes need updating, regardless of traversal order; the pull phase then lazily recomputes only the dirty nodes from the outputs backward and marks them clean. Each node is visited at most once per phase, running in O(n) time where n is the number of affected nodes, and satisfying all four criteria. The main caveat is that the entire pull phase must finish synchronously between two input mutations, so long-running async work has to be handled outside the core graph.&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_!Fevp!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Feb1ae3fa-80a7-464d-97a2-869170caaa2f_2360x2960.png" alt="Git Workflow: Essential Commands"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!huHJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9262eb79-a1cc-4308-8f72-01fdf91e429d_1388x1782.jpeg" alt="How can Cache Systems go wrong?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7p1w!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd5ebb98a-9f98-4c32-9268-2d14086569d8_2360x2960.png" alt="Top Cyber Attacks Explained"&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 #84</title><link>https://miti99.com/en/post/2026/02/26/</link><pubDate>Thu, 26 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #84.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="automatic-programming"&gt;&lt;a href="https://antirez.com/news/159" rel="noopener noreferrer"&gt;Automatic programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, coins the term &amp;ldquo;automatic programming&amp;rdquo; for writing software with AI assistance—and believes that before long, we will simply call it &amp;ldquo;programming.&amp;rdquo; He draws a sharp line between automatic programming and &amp;ldquo;vibe coding&amp;rdquo;: in vibe coding, you hand a vague prompt to an LLM and let it generate software while you stay mostly out of the loop, only nudging it when something breaks. In automatic programming, the human programmer understands everything happening under the hood, continuously steers the model according to their own vision across every level of abstraction—from high-level architecture down to how a specific function should be implemented—and decides &lt;em&gt;what&lt;/em&gt; to build in the first place. Because of that, the same model produces vastly different results depending on who is in the driver&amp;rsquo;s seat.&lt;/p&gt;
&lt;p&gt;Sanfilippo argues that code produced this way is genuinely yours and something you have every right to be proud of. Since the training data behind these models came from humanity&amp;rsquo;s collective output, he sees LLMs more as a shared gift from humanity to itself than as theft. He points to Redis as an example: technically speaking, Redis contained very little novel computer science—just basic data structures and networking code that any competent systems programmer could write; what made Redis valuable was the product vision and taste behind it. His conclusion: programming can now be automated, but vision (for now) cannot.&lt;/p&gt;
&lt;h2 id="software-performance-engineering-the-ideas-i-keep-coming-back-to"&gt;&lt;a href="https://ricomariani.medium.com/software-performance-engineering-the-ideas-i-keep-coming-back-to-6f421b6a9505" rel="noopener noreferrer"&gt;Software Performance Engineering: The Ideas I Keep Coming Back To&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rico Mariani distills eight performance engineering ideas he keeps returning to across decades and programming languages, centered on one core theme: performance is not about clever tricks or micro-optimizations, but a way of thinking. First, performance is a systems problem: the hardest issues almost always stem from architectural choices like excessive allocations, poor data locality, hidden synchronization, or unbounded growth rather than a single slow function. Abstractions are never free—they merely hide cost, so you need to know what they expand into and how often they run. Cost models matter more than APIs: two APIs that look identical on the surface can differ by 10x because one allocates on every call or touches cold memory. And profilers only tell you &lt;em&gt;where&lt;/em&gt; time went, not &lt;em&gt;why&lt;/em&gt; it was spent.&lt;/p&gt;
&lt;p&gt;Memory is the real bottleneck, as the speed gap between CPUs and main memory continues to widen. Meanwhile, Knuth&amp;rsquo;s famous quote that &amp;ldquo;premature optimization is the root of all evil&amp;rdquo; is routinely abused: the real sin is designing systems with zero cost awareness, which leads to &amp;ldquo;premature pessimization.&amp;rdquo; Programming languages also shape how engineers think about cost—languages that make ownership and lifetimes explicit make cost much easier to reason about. Finally, performance rarely dies in a single commit; it erodes through a thousand tiny, invisible cuts, requiring regular check-ins to verify that reality still matches your architectural intent.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://oblique.security/blog/go-synctest/" rel="noopener noreferrer"&gt;Go&amp;rsquo;s synctest is amazing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eric Chiang from Oblique shares his experience using Go 1.25&amp;rsquo;s &lt;code&gt;testing/synctest&lt;/code&gt; package to test a codebase full of background control loops, such as purging expired database sessions or running distributed leader election across instances. The headline feature of &lt;code&gt;synctest&lt;/code&gt; is running tests inside an isolated &amp;ldquo;bubble&amp;rdquo; with a fake clock so &lt;code&gt;time.Sleep&lt;/code&gt; completes almost instantaneously. According to Chiang, however, its even bigger superpower is letting you deterministically reason about the &lt;em&gt;ordering&lt;/em&gt; of concurrent events. &lt;code&gt;synctest&lt;/code&gt; only advances its fake clock when every goroutine inside the bubble is durably blocked—typically on channels, wait groups, or time operations—and then advances the clock just enough to wake the shortest sleep. That lets tests use time itself as a synchronization primitive, something that would be an anti-pattern in production code; for example, a background ticker loop that runs once a minute is guaranteed to execute exactly three times after sleeping for three fake minutes.&lt;/p&gt;
&lt;p&gt;In practice, simply sleeping slightly longer than the interval of &lt;code&gt;RunDeleteExpiredSessions&lt;/code&gt; guarantees the background cleanup pass has finished before the test asserts against the database, and the entire test finishes in under a second. His team even applied &lt;code&gt;synctest&lt;/code&gt; to their database-backed leader election logic spanning dozens of concurrent loops without modifying a single line of production code, pausing execution at arbitrary points in time to inspect database state. He notes two caveats to keep in mind: understanding which operations count as &amp;ldquo;durably blocked&amp;rdquo; (network and file I/O do not) and ensuring all spawned goroutines exit cleanly before the bubble closes.&lt;/p&gt;
&lt;h2 id="why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying"&gt;&lt;a href="https://dev.to/rpereira15/why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying-1i5k" rel="noopener noreferrer"&gt;Why Clean Architecture Confuses Everyone (And How I Learned to Stop Worrying)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on more than 10 years of software engineering experience, Rômulo Pereira explains why Clean Architecture confuses so many developers: teams spend hours arguing over folder structures while missing the core principle. Frameworks like Spring Boot make violating boundaries effortless—a single annotation on a domain class tightly couples your business logic to JPA, Jackson, and the framework runtime. Organizing packages by technical layer (&lt;code&gt;controller&lt;/code&gt;, &lt;code&gt;service&lt;/code&gt;, &lt;code&gt;repository&lt;/code&gt;, &lt;code&gt;model&lt;/code&gt;) also pulls you into technology-first thinking, whereas organizing by feature (&lt;code&gt;order&lt;/code&gt;, &lt;code&gt;product&lt;/code&gt;, &lt;code&gt;customer&lt;/code&gt;) keeps the focus on what the system actually &lt;em&gt;does&lt;/em&gt;. From his experience building high-volume billing systems and real-time data platforms, he argues that business logic should be &amp;ldquo;boring&amp;rdquo;: completely agnostic to where data is stored, whether requests arrive over REST or a message queue, or which framework is in use. And don&amp;rsquo;t create an interface for every class just because &amp;ldquo;Clean Architecture requires ports and adapters&amp;rdquo;—an interface that will only ever have one implementation is pure ceremony.&lt;/p&gt;
&lt;p&gt;The real litmus test is replaceability: could you swap your database, move from REST to GraphQL, or upgrade your framework without touching your core domain logic? His pragmatic approach is to write plain, annotation-free use cases and push Spring wiring to the outer boundary of the system. Instead of debating package names, ask whether your business rules are easy to unit-test in milliseconds, how many files break when you upgrade a framework, and whether a new teammate can tell what the system does at a glance. Start simple, keep business rules pure, and test them without mocking the entire world.&lt;/p&gt;
&lt;h2 id="the-third-golden-age-of-software-engineering--thanks-to-ai"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-third-golden-age-of-software" rel="noopener noreferrer"&gt;The third golden age of software engineering – thanks to AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt; podcast, Gergely Orosz sits down with Grady Booch, co-creator of UML and Chief Scientist for Software Engineering at IBM. Booch divides the history of computing into three &amp;ldquo;golden ages&amp;rdquo;: the first revolved around algorithms (1940s to 1970s), the second around object-oriented abstractions (1970s to 2000s), and the third—which we are in today—around systems of systems. In his view, this third age began when our unit of abstraction rose to entire libraries, frameworks, and platforms, well before the current AI wave. He reminds listeners that existential dread in software is nothing new: when compilers and high-level languages first appeared, assembly programmers feared they would be replaced, yet the profession evolved and expanded. AI coding tools simply raise the level of abstraction one step further; as he puts it, &amp;ldquo;tools change, the problems remain the same.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Booch notes that today&amp;rsquo;s AI models are trained primarily on problems that have already been solved thousands of times, making them great at automating familiar patterns like web CRUD apps while the true frontier of computing remains vast. When the industry moves at breakneck speed, strong fundamentals become more important, not less. He does acknowledge that routine software delivery plumbing is the easiest target for automation, meaning engineers in purely mechanical roles will need to upskill. His closing message: this is a moment to soar, not to fear the abyss.&lt;/p&gt;
&lt;h2 id="ai-coding-workflow"&gt;&lt;a href="https://newsletter.systemdesign.one/p/ai-coding-workflow" rel="noopener noreferrer"&gt;AI coding workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this guest post for &lt;em&gt;The System Design Newsletter&lt;/em&gt;, Louis-François Bouchard shares the workflow he uses to get reliable results from AI coding tools after realizing AI is not a &amp;ldquo;vending machine&amp;rdquo; where you paste a bug and get working production code out. His core mental model: treat AI like a brilliant new teammate who joined your project five minutes ago—it types fast and knows every language, but has zero awareness of your architecture, conventions, or constraints unless you tell it. AI works best inside a tight six-step loop: Context (supplying the README, rules files like &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;CLAUDE.md&lt;/code&gt;, relevant files, and stack traces or logs), Plan (asking for a strategy before any code is written, because fixing a plan is much cheaper than debugging code), Code (making small, incremental changes that are easy to review), Review, Test, and Iterate.&lt;/p&gt;
&lt;p&gt;He also uses a lightweight multi-agent pattern with four distinct roles: a Planner to break down tasks and spot edge cases, an Implementer to write code strictly following the approved plan, a Tester to write unit and edge-case tests, and an Explainer to summarize what changed and why. He pairs a strong reasoning model for planning with a faster model for implementation. The post also catalogs common failure modes like context drift in long chats, hallucinated or outdated APIs, debugging death spirals, gradual codebase rot, and over-reliance on AI. The overarching rule: treat AI output as a first draft, and always rely on human review and automated tests as your safety net.&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://substack-post-media.s3.amazonaws.com/public/images/625a6789-c32d-4a27-a5f5-c174fb920637_2360x2960.png" alt="Git pull vs. git fetch"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-Lov!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fcf928dd3-de16-4605-a702-762df269c9f2_2250x2862.png" alt="Top Authentication Techniques"&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 #78</title><link>https://miti99.com/en/post/2026/02/01/</link><pubDate>Sun, 01 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #78.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-next-two-years-of-software-engineering"&gt;&lt;a href="https://addyosmani.com/blog/next-two-years/" rel="noopener noreferrer"&gt;The Next Two Years of Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani observes that the software industry is at an inflection point: AI coding tools have evolved from autocomplete suggestions into autonomous agents that execute end-to-end tasks, while the hiring boom has given way to an efficiency mandate where companies favor experienced engineers and small, well-tooled teams. Rather than making single-track predictions, he poses five open questions through 2026, each paired with two contrasting scenarios. Junior hiring could collapse (a Harvard study found junior roles dropped roughly 9–10% after companies adopted generative AI) or rebound as software expands into every industry. Foundational computer science skills could atrophy or become more valuable than ever. The developer role could narrow into an AI code reviewer or expand into a full-system orchestrator. Narrow specialists risk displacement, while T-shaped engineers (deep in one or two areas, broad across many) are in high demand. And traditional CS degrees could be overtaken by bootcamps, online courses, and internal apprenticeships.&lt;/p&gt;
&lt;p&gt;With 84% of developers already using or planning to use AI, value lies in reviewing AI output for logic bugs, security vulnerabilities, and requirement drift; the best engineers aren&amp;rsquo;t the ones who write code the fastest, but the ones who know when not to trust AI. Juniors should use AI to learn rather than as a crutch; seniors should anchor quality assurance, mentorship, and architecture. The common denominator is continuous learning.&lt;/p&gt;
&lt;h2 id="databases-in-2025-a-year-in-review"&gt;&lt;a href="https://www.cs.cmu.edu/~pavlo/blog/2026/01/2025-databases-retrospective.html" rel="noopener noreferrer"&gt;Databases in 2025: A Year in Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Pavlo (Carnegie Mellon University) looks back at the database world in 2025, starting with PostgreSQL&amp;rsquo;s continued dominance. Version 18 added an asynchronous I/O subsystem and B-tree skip scans. The business side was even livelier: Databricks paid $1 billion to acquire Neon, Snowflake paid $250 million for CrunchyData, Microsoft launched HorizonDB, and three horizontally scalable PostgreSQL sharding projects—Multigres (Supabase), Neki (PlanetScale), and PgDog—entered the ring. 2025 was also the year every DBMS shipped an MCP (Model Context Protocol) server, exploding after OpenAI backed the standard in March. Pavlo cautions that these servers mostly just forward queries to the database, making least-privilege access essential. The columnar file format space heated up as well, with five new formats challenging Parquet: FastLanes, F3, Vortex, AnyBlox, and Amudai.&lt;/p&gt;
&lt;p&gt;The industry roundup covers a wave of acquisitions: IBM bought DataStax (for an estimated $3 billion) and Confluent, Salesforce acquired Informatica ($8 billion), and Fivetran and dbt Labs announced a surprise merger. Databricks raised two massive funding rounds of $4 billion and $1 billion, while several database startups shut down, including Fauna, PostgresML, Hydra, MyScaleDB, and Voltron Data. The post closes with Oracle founder Larry Ellison briefly becoming the richest person in the world with an estimated net worth of $393 billion—which Pavlo notes makes him the richest database person in history, surpassing even John D. Rockefeller on an inflation-adjusted basis.&lt;/p&gt;
&lt;h2 id="12-predictions-for-2026"&gt;&lt;a href="https://tomtunguz.com/2026-predictions/" rel="noopener noreferrer"&gt;12 Predictions for 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz shares 12 predictions for 2026 centered on AI agents moving into real production work. For the first time, enterprises will spend more on agents than on human labor in certain workflows, much as riders willingly pay a ~31% premium to take a Waymo over an Uber. 2026 is poised to set a liquidity record with potential IPOs from SpaceX, OpenAI, Anthropic, Stripe, and Databricks. Vector databases will enjoy a renaissance as essential agent infrastructure. According to METR, the task duration AI can reliably complete doubles every seven months, putting agents on track to run 8+ hour workflows autonomously by year&amp;rsquo;s end. AI budgets will face real scrutiny for the first time, pushing small and open-source models ahead thanks to up to 10x lower costs, while Google widens its lead through strength across frontier models, video generation, and search.&lt;/p&gt;
&lt;p&gt;Agent observability will become the most fiercely contested infrastructure layer. Stablecoins are projected to capture 30% of cross-border payments, eating into SWIFT&amp;rsquo;s volume. Agents will issue at least an order of magnitude more queries than humans, forcing database architectures to adapt. US data center investment will reach 3.5% of GDP, rivaling the railroad boom. The web will shift toward agent-first design as purchasing decisions increasingly begin with agent-led research, and Cloudflare will emerge as the toll collector for agent payments via the x402 protocol, reviving the long-dormant HTTP &lt;code&gt;402 Payment Required&lt;/code&gt; status code.&lt;/p&gt;
&lt;h2 id="the-garbage-collection-handbook"&gt;&lt;a href="https://gchandbook.org/index.html" rel="noopener noreferrer"&gt;The Garbage Collection Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page introduces the second edition of &lt;em&gt;The Garbage Collection Handbook&lt;/em&gt;, the classic reference on automatic memory management. Descending from Richard Jones&amp;rsquo;s original &lt;em&gt;Garbage Collection&lt;/em&gt; (Wiley, 1996) and the first Handbook edition in 2012, this new edition thoroughly updates the material to reflect modern hardware, software, and runtime environments. It progresses from simple, traditional algorithms to modern parallel, incremental, concurrent, and real-time collectors, illustrated throughout with pseudocode and diagrams. The book analyzes high-performance commercial collectors in detail, explains tricky runtime interface mechanics, and adds over 90 pages of new material including chapters on persistence (non-volatile memory) and energy-aware garbage collection.&lt;/p&gt;
&lt;p&gt;Because nearly all modern programming languages rely on garbage collection, understanding how collectors work helps developers confidently select and tune them for their workloads. The e-book edition features over 37,000 internal cross-references linking chapters, sections, algorithms, figures, and original research papers, accompanied by an online bibliography database of nearly 3,400 garbage-collection publications. The first edition of the Handbook was also translated into Chinese and Japanese in 2016.&lt;/p&gt;
&lt;h2 id="vibe-coded-is-the-new"&gt;&lt;a href="https://gabriel-afonso.com/blog/vibe-coded-is-the-new-made-in-china/" rel="noopener noreferrer"&gt;Vibe-Coded Is the New &amp;ldquo;Made in China&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel Afonso notices that on &lt;code&gt;r/selfhosted&lt;/code&gt;, any new project labeled &amp;ldquo;vibe-coded&amp;rdquo; is immediately met with skepticism. Coined by Andrej Karpathy in early 2025, &amp;ldquo;vibe coding&amp;rdquo; means giving in to the vibes and letting large language models handle the implementation while you focus only on what you want to build. In Afonso&amp;rsquo;s view, the backlash usually isn&amp;rsquo;t about the code quality itself, but what the label signals. Historically, the sheer difficulty of building software acted as a natural filter: anyone who shipped an open-source project had invested enough sweat equity that they were likely to stick around and maintain it. Now that anyone can spin up an app in a few hours and code far beyond their actual skill level, a project&amp;rsquo;s author might not even understand the code they published. As a result, &amp;ldquo;vibe-coded&amp;rdquo; has become like the old &amp;ldquo;Made in China&amp;rdquo; label—shorthand for cheap, disposable software.&lt;/p&gt;
&lt;p&gt;He draws a parallel to chess: after Deep Blue defeated Kasparov in 1997, chess became even more popular as humans learned to work alongside engines. Respected developers like DHH, Tanner Linsley, and Boris Cherny (creator of Claude Code, who shared that 100% of his contributions over the prior 30 days were written by Claude Code) use AI heavily without drawing backlash because they remain true authors who understand and own their systems. Time remains the most reliable filter: a project maintained for two years with real users proves a level of commitment that cannot be faked. Today&amp;rsquo;s skepticism is simply the ecosystem&amp;rsquo;s immune system adapting while the rules are being rewritten.&lt;/p&gt;
&lt;h2 id="the-production-bug-that-made-me-care-about-undefined-behavior"&gt;&lt;a href="https://gaultier.github.io/blog/the_production_bug_that_made_me_care_about_undefined_behavior.html" rel="noopener noreferrer"&gt;The production bug that made me care about undefined behavior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philippe Gaultier recounts a production bug in a C++ system processing billions of euros in payments each year. An HTTP endpoint was supposed to return either &lt;code&gt;error&lt;/code&gt; or &lt;code&gt;succeeded&lt;/code&gt; set to &lt;code&gt;true&lt;/code&gt;—never both—yet clients occasionally received responses with both fields set to &lt;code&gt;true&lt;/code&gt;, even though each field was assigned at most once in mutually exclusive branches. The culprit was the declaration &lt;code&gt;Response response;&lt;/code&gt;. In C, reading an uninitialized struct field is straightforward undefined behavior; C++ is subtler: because &lt;code&gt;Response&lt;/code&gt; contained a &lt;code&gt;std::string&lt;/code&gt;, it was a non-POD type, so the compiler synthesized and called a default constructor—which default-constructed the &lt;code&gt;std::string&lt;/code&gt; but left the two &lt;code&gt;bool&lt;/code&gt; fields uninitialized with garbage stack bytes.&lt;/p&gt;
&lt;p&gt;The fix is to use value initialization (&lt;code&gt;Response response{};&lt;/code&gt;) to zero-initialize every field, or provide explicit default member initializers. Compilers emit no warning even with all warning flags enabled; &lt;code&gt;clang-tidy&lt;/code&gt; catches it statically, and AddressSanitizer paired with UndefinedBehaviorSanitizer (or Valgrind) catches it at runtime, though only if test coverage hits that code path and the stack happens to contain non-zero bytes. Gaultier wrote a custom &lt;code&gt;libclang&lt;/code&gt; plugin to scan the entire codebase for similar bugs. The post also highlights a bizarre C++ quirk: reading an uninitialized &lt;code&gt;std::byte&lt;/code&gt; or &lt;code&gt;unsigned char&lt;/code&gt; is permitted in many cases without triggering undefined behavior, whereas reading an uninitialized &lt;code&gt;bool&lt;/code&gt; is instant UB. His takeaway: C++ has far too many initialization syntaxes, looks deceptively like C while behaving differently, and changes its rules across language standards.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://antirez.com/news/158" rel="noopener noreferrer"&gt;Don&amp;rsquo;t fall into the anti-AI hype&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, loves crafting software line by line, yet admits that AI has changed programming forever. He used to think this inflection point was still a few years away, but changed his mind now that modern LLMs can complete major features or medium-sized projects almost autonomously. In a single week, by writing prompts and occasionally reviewing code to steer direction, he finished four projects in hours that would otherwise have taken weeks: adding UTF-8 support to his &lt;code&gt;linenoise&lt;/code&gt; library along with a pseudo-terminal test harness; fixing transient timing and TCP deadlock test failures in Redis; having Claude Code write a 700-line pure C library in 5 minutes to run BERT-style embedding inference within 15% of PyTorch&amp;rsquo;s speed; and having Claude Code reproduce internal Redis Streams changes from a design spec in about 20 minutes.&lt;/p&gt;
&lt;p&gt;In his view, writing code by hand is no longer necessary for most projects. He is happy that his open-source code was used to train models, seeing it as a continuation of the open-source mission to democratize code and knowledge; AI will empower small teams to compete with tech giants just as open source did in the 1990s. Still, he worries about this technology concentrating in the hands of a few corporations. His advice: don&amp;rsquo;t fall for anti-AI hype—give modern tools a serious multi-week trial rather than a five-minute test, because the joy of programming is building, and we can now build more and better than ever.&lt;/p&gt;
&lt;h2 id="performance-hints"&gt;&lt;a href="https://abseil.io/fast/hints.html" rel="noopener noreferrer"&gt;Performance Hints&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the &amp;ldquo;Performance Hints&amp;rdquo; guide written by Jeff Dean and Sanjay Ghemawat on Google&amp;rsquo;s Abseil site, distilling the principles and techniques they use when optimizing software performance. They quote Donald Knuth in full: we should forget about small efficiencies about 97% of the time, yet we should not pass up our opportunities in that critical 3%. The common advice to &amp;ldquo;write it simply first and optimize later&amp;rdquo; often fails in practice because large systems built without regard for performance end up with flat profiles where CPU time is diffused across thousands of functions with no obvious hotspot; instead, engineers should instinctively choose the faster alternative whenever it doesn&amp;rsquo;t noticeably harm readability. The guide shows how to do back-of-the-envelope estimates using basic latency numbers (L1 cache ~0.5 ns, branch mispredict ~5 ns, main memory ~50 ns), measure with profilers, and tackle flat CPU profiles by stacking many 1% wins or restructuring higher-level architecture.&lt;/p&gt;
&lt;p&gt;The remainder of the document is a catalog of concrete techniques with code examples: designing APIs that allow optimization behind encapsulation boundaries (such as bulk operations and passing buffers); algorithmic improvements; compact memory representations that touch fewer cache lines (indices instead of pointers, arenas, arrays instead of maps, bitvectors); reducing allocations by pre-sizing containers, reusing objects, and avoiding copies; avoiding unnecessary work via fast paths, precomputation, caching, and keeping logging off hot paths; controlling code size; and parallelizing with short critical sections, sharding to reduce contention, SIMD, and avoiding false sharing. It concludes with specific advice for Protocol Buffers and containers like &lt;code&gt;absl::flat_hash_map&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-job-market-2026-data-trends-and-outlook"&gt;&lt;a href="https://www.finalroundai.com/blog/software-engineering-job-market-2026" rel="noopener noreferrer"&gt;Software Engineering Job Market 2026: Data, Trends and Outlook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article analyzes why software engineering—once considered the safest career track—now feels vulnerable amid near-weekly layoff headlines. Indeed job-posting data via FRED shows software roles peaked in mid-2022, plunged through 2024, and have yet to rebound to pandemic highs. The primary driver isn&amp;rsquo;t AI, but the 2021–2022 digitization bubble: fear of missing out and near-zero interest rates led everyone from Big Tech to startups to overhire massively. When demand normalized, AI became a convenient scapegoat for headcount reductions. Another major factor is global remote hiring: a senior engineer might cost $100,000+ per year in the US versus $40,000 in India, and telling investors &amp;ldquo;we&amp;rsquo;re replacing roles with AI&amp;rdquo; sounds much more forward-looking than &amp;ldquo;we&amp;rsquo;re offshoring.&amp;rdquo; A METR study even found that experienced developers were 19% slower when using AI tools across 246 tasks.&lt;/p&gt;
&lt;p&gt;Even so, the profession isn&amp;rsquo;t disappearing—only demand for basic boilerplate coding is shrinking. The US Bureau of Labor Statistics still projects ~15% employment growth for software developers, SignalFire reports that Meta, Netflix, Uber, and Google are hiring faster than attrition, and Antler founder Magnus Grimeland points out that more AI-generated code means more bugs that require human engineers to fix. What has changed is the skill bar: system design, performance, security, and effective AI orchestration. Entry-level candidates face the toughest market, with junior postings down roughly 40% compared to pre-2022 levels. The article closes with recommended languages to learn in 2026: Python for AI/ML, JavaScript/TypeScript for frontend, Go for backend and cloud infrastructure, Java for enterprise, and Swift for iOS.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!0P7Z!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7546f89c-8b6f-4ced-8d40-4e0137ab5941_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Co3P!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb7f3c175-c0d6-4d02-992d-114ac588b45c_2252x2752.png" alt="Top Developer Tools You Can Use in 2026"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Ty5s!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fecc68f5e-6353-4487-a779-92bb11440bc5_2360x2960.png" alt="5 Rate Limiting Strategies To Protect the System"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!dPjo!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2543392-5e04-4dd6-b39a-72fdfe3a3048_2360x2770.png" alt="How Live Streaming Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MJUT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F06243bf8-f149-4075-bc81-99af15be3579_6001x7802.png" alt="5 Leader Election Algorithms Powering Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Xrbz!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c99d0d5-8e5b-4e82-bb28-9fbd470e3bc6_2250x2624.png" alt="A Guide to Database Sharding"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!NCWv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0adc9c84-37f2-4a96-96a6-f7f26bbd1b7e_2360x2960.jpeg" alt="Modern Storage Systems"&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 #70</title><link>https://miti99.com/en/post/2025/12/13/</link><pubDate>Sat, 13 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #70.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-developer-productivity-paradox-why-faster-coding-doesn"&gt;&lt;a href="https://gradle.com/blog/developer-productivity-paradox-faster-coding-slower-delivery/" rel="noopener noreferrer"&gt;The developer productivity paradox: Why faster coding doesn&amp;rsquo;t mean faster software delivery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Trisha Gee (Gradle) distills a central theme from DPE Summit 2025: the developer productivity paradox. Nearly every developer now uses AI (~90%) and over 80% believe it makes them more productive, yet organizational delivery metrics have barely budged. The 2025 DORA report shows that AI is neither the problem nor the cure—it is a mirror and an amplifier of whatever strengths and weaknesses an engineering organization already has. Because AI models carry an inherent error rate, generating more code faster actually makes systems &lt;em&gt;less&lt;/em&gt; stable unless the surrounding delivery pipeline is solid enough to catch defects. Context-switching costs also eat up the time saved: every interruption takes 15–20 minutes to recover from, and AI introduces new interruptions of its own as developers verify outputs, tweak prompts, or jump between tools to debug subtle mistakes.&lt;/p&gt;
&lt;p&gt;To overcome the paradox, Gee argues for treating AI adoption as an organization-wide transformation grounded in Developer Productivity Engineering (DPE): invest in platform engineering and shared standards, strengthen rollback mechanisms, and tighten CI/CD feedback loops; shrink batch sizes, eliminate toil, and apply value-stream management; measure end-to-end flow and business outcomes rather than lines of code or pull request counts; and train engineers to critically evaluate AI-generated code instead of blindly clicking &amp;ldquo;Accept.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="what-actually-makes-you-senior"&gt;&lt;a href="https://terriblesoftware.org/2025/11/25/what-actually-makes-you-senior/" rel="noopener noreferrer"&gt;What Actually Makes You Senior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, the core skill that separates senior engineers from everyone else isn&amp;rsquo;t technical trivia, but the ability to &lt;strong&gt;reduce ambiguity&lt;/strong&gt;. A mid-level engineer can execute a well-defined spec cleanly, but when handed a vague problem like &amp;ldquo;we need to improve performance&amp;rdquo; or &amp;ldquo;users are complaining about the signup flow,&amp;rdquo; a senior engineer digs in: asking questions nobody else thought to ask, separating signal from noise, and deciding what to tackle now versus what to defer. They ask what the real problem is, who the users are and what frustrates them, which assumptions the plan depends on that might be wrong, and what the blast radius looks like if they ship and those assumptions fail. In doing so, they &lt;strong&gt;de-risk the project&lt;/strong&gt;, turning &amp;ldquo;I have no idea what this even is&amp;rdquo; into &amp;ldquo;two small well-scoped projects and one thing we shouldn&amp;rsquo;t build at all.&amp;rdquo; Done well, this work is nearly invisible—projects simply run smoothly with fewer surprises and fewer outages.&lt;/p&gt;
&lt;p&gt;The author criticizes tech hiring for fixating on keyword checklists, years of experience, and LeetCode puzzles, producing &amp;ldquo;senior&amp;rdquo; engineers who can invert a binary tree on a whiteboard but freeze in front of a half-baked spec. The good news is that reducing ambiguity isn&amp;rsquo;t an innate gift, but a skill built through practice: start with the next vague ticket in your queue and spend time clarifying it upfront instead of waiting to be spoon-fed requirements or jumping straight into code.&lt;/p&gt;
&lt;h2 id="becoming-unblockable"&gt;&lt;a href="https://www.seangoedecke.com/unblockable/" rel="noopener noreferrer"&gt;Becoming unblockable&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares practical tactics for becoming &amp;ldquo;unblockable&amp;rdquo;—always finding a way to keep moving forward when obstacles arise. First, keep more than one task in flight at a time, just like a CPU core switching threads while waiting on I/O; avoid juggling two urgent deadlines at once, and pick low-urgency background work like refactoring, performance tuning, or mandatory training rather than grabbing another feature ticket. Second, front-load the parts of a project most likely to get blocked (such as database migrations that require another team&amp;rsquo;s sign-off) or spark design debates. Be ruthless about your tooling: stick to mainstream development setups, treat a broken local environment with the same urgency as a production outage, and when you&amp;rsquo;re truly stuck locally, find workarounds like running tests in CI or deploying to a staging environment.&lt;/p&gt;
&lt;p&gt;When you hit an error coming from another team&amp;rsquo;s service, don&amp;rsquo;t immediately declare yourself blocked—go read their source code and logs yourself; today you can even point AI agents like Codex or Claude Code at their repo, which Goedecke estimates gives the right answer about a third of the time. Beyond code, build goodwill with engineers on other teams by being helpful so you have fast informal backchannels when you need a favor, and secure &amp;ldquo;air cover&amp;rdquo; from directors or VPs by aligning your projects with top company priorities.&lt;/p&gt;
&lt;h2 id="treat-test-code-like-production-code"&gt;&lt;a href="https://blog.ploeh.dk/2025/12/01/treat-test-code-like-production-code/" rel="noopener noreferrer"&gt;Treat test code like production code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mark Seemann argues that test code deserves the same care as production code: the same coding standards, readability, structure, and code-review rigor. In practice, test suites are often treated as second-class citizens—properly indented, yet full of copy-pasted duplication, commented-out &amp;ldquo;zombie&amp;rdquo; tests, and arbitrary &lt;code&gt;sleep&lt;/code&gt; calls in place of proper thread synchronization. Coding standards and design principles don&amp;rsquo;t exist to appease the compiler; they exist so humans—usually your future self—can understand and maintain the system. When a project has strong test coverage, the test suite is huge, making the DRY principle even more important: without it, a minor production API change triggers &amp;ldquo;Shotgun Surgery&amp;rdquo; across dozens of broken tests.&lt;/p&gt;
&lt;p&gt;For test-specific design questions like structure, organization, naming, and determinism, Seemann recommends &lt;em&gt;xUnit Test Patterns&lt;/em&gt; as the definitive reference. He also pushes back against the slogan that tests should be &amp;ldquo;DAMP, not DRY,&amp;rdquo; noting that descriptive, meaningful phrasing is a virtue whether code is duplicated or factored into helpers. There are still sensible exceptions, mostly around security when test code is never deployed: hardcoding dummy test passwords or skipping input validation in test helpers is fine. Platform-specific exceptions make sense too, such as relaxing &lt;code&gt;.NET&lt;/code&gt;&amp;rsquo;s &lt;code&gt;ConfigureAwait&lt;/code&gt; rule in tests or allowing orphan instances in Haskell test suites.&lt;/p&gt;
&lt;h2 id="how-good-engineers-write-bad-code-at-big-companies"&gt;&lt;a href="https://www.seangoedecke.com/bad-code-at-big-companies/" rel="noopener noreferrer"&gt;How good engineers write bad code at big companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke explains why big tech companies can hire armies of talented engineers and still produce terrible code. The core reason is that large companies are &lt;strong&gt;full of engineers working outside their area of expertise&lt;/strong&gt;. With average tenure hovering around one to two years and frequent reorgs shuffling teams, many services are a decade old while most code changes are made by relative newcomers—engineers within their first six months at the company, in that codebase, or in that programming language. The few long-tenured veterans who deeply understand the system can catch issues in code review, but that stewardship role is informal and they are perpetually stretched thin by their own deliverables.&lt;/p&gt;
&lt;p&gt;The typical big-company engineer is therefore a capable developer racing to hit a deadline inside an unfamiliar codebase—doing their best in an environment that isn&amp;rsquo;t set up to produce high-craft code. In Goedecke&amp;rsquo;s view, this is a deliberate executive trade-off: leadership prioritizes organizational flexibility and fungible headcount over deep codebase mastery and code quality, and individual engineers have very little power to change it. He contrasts &amp;ldquo;pure engineering&amp;rdquo; (self-contained domains like compilers, where bad code usually reflects low skill) with &amp;ldquo;impure engineering&amp;rdquo; (more like contract electrical or plumbing work under deadline pressure, where messy code is an inevitable byproduct of the environment). At big companies, bad code happens because almost everyone is perpetually working in unfamiliar territory.&lt;/p&gt;
&lt;h2 id="the-success-trap"&gt;&lt;a href="https://mikefisher.substack.com/p/the-success-trap" rel="noopener noreferrer"&gt;The Success Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mike Fisher explores how success can quietly narrow your freedom and options. He contrasts a waiter at a neighborhood diner—whose skills are portable enough to switch jobs or careers at any time—with a waiter at a Michelin-starred restaurant, whose mastery is far higher but whose exit options are much narrower without taking a step down. In organizational theory, the &amp;ldquo;success trap&amp;rdquo; describes becoming so good at exploiting your current strengths that you stop exploring new opportunities; it is closely related to Clayton Christensen&amp;rsquo;s &lt;em&gt;Innovator&amp;rsquo;s Dilemma&lt;/em&gt;, except the innovator&amp;rsquo;s dilemma is disruption from the outside, whereas the success trap is rot from within.&lt;/p&gt;
&lt;p&gt;Fisher illustrates this with three examples: an engineer promoted up the management ladder until he no longer built anything himself, who eventually took a pay cut at a startup just to write code again; Kodak inventing the digital camera in 1975 and shelving it to protect its film cash cow; and Radiohead deliberately reinventing their sound with &lt;em&gt;Kid A&lt;/em&gt; right after the massive success of &lt;em&gt;OK Computer&lt;/em&gt;. To escape the trap, organizations need to institutionalize curiosity through dedicated experimentation time, while individuals should regularly put themselves back in the beginner&amp;rsquo;s seat and value learning velocity over comfort. For leaders, it requires a mindset of stewardship—holding success lightly and optimizing for renewal rather than coasting on past wins—because freedom, not achievement, is the true measure of success.&lt;/p&gt;
&lt;h2 id="writing-a-good-claudemd"&gt;&lt;a href="https://www.humanlayer.dev/blog/writing-a-good-claude-md" rel="noopener noreferrer"&gt;Writing a good CLAUDE.md&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide from HumanLayer starts from a simple fact: LLMs are stateless. At the beginning of every session, a coding agent knows nothing about your repository, and &lt;code&gt;CLAUDE.md&lt;/code&gt; (or &lt;code&gt;AGENTS.md&lt;/code&gt;) is the one file injected into every conversation by default. Its job is to onboard Claude into the codebase by answering three questions: &lt;strong&gt;WHAT&lt;/strong&gt; (the tech stack and directory structure, especially in monorepos), &lt;strong&gt;WHY&lt;/strong&gt; (the purpose of each component), and &lt;strong&gt;HOW&lt;/strong&gt; (how to work in the repo—running tests, typechecks, and builds). The author notes that Claude frequently ignores &lt;code&gt;CLAUDE.md&lt;/code&gt; because Claude Code wraps it in a system reminder telling the model to ignore instructions that aren&amp;rsquo;t &amp;ldquo;highly relevant to the current task&amp;rdquo;—so the more task-specific clutter you stuff into the file, the more likely Claude is to tune the whole thing out.&lt;/p&gt;
&lt;p&gt;Key recommendations: fewer instructions are better, since frontier reasoning models reliably follow only about 150–200 instructions in total and Claude Code&amp;rsquo;s system prompt already uses ~50 of them; keep &lt;code&gt;CLAUDE.md&lt;/code&gt; under 300 lines and as short as possible (HumanLayer&amp;rsquo;s own root file is under 60 lines), containing only rules that apply to every single task. Use progressive disclosure: put workflow-specific docs in separate Markdown files and link to them from &lt;code&gt;CLAUDE.md&lt;/code&gt;, and reference &lt;code&gt;file:line&lt;/code&gt; pointers instead of pasting code snippets that quickly go stale. Never use an LLM as an expensive linter—use deterministic linters and formatters wired into hooks or slash commands instead. Finally, don&amp;rsquo;t just run &lt;code&gt;/init&lt;/code&gt; and call it a day: &lt;code&gt;CLAUDE.md&lt;/code&gt; is the highest-leverage point of the entire agent harness, so craft every line deliberately.&lt;/p&gt;
&lt;h2 id="we-should-all-be-using-dependency-cooldowns"&gt;&lt;a href="https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependency-cooldowns" rel="noopener noreferrer"&gt;We should all be using dependency cooldowns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;William Woodruff argues that dependency cooldowns are a free, low-effort, and remarkably effective defense against the vast majority of open-source supply-chain attacks. Most supply-chain attacks follow the same playbook: an attacker compromises a popular project (usually via phished credentials or a CI/CD vulnerability), publishes a malicious release to PyPI, npm, or GitHub, downstream users automatically pull the update, security researchers spot the anomaly, and the registry yanks the malicious package. While the attacker&amp;rsquo;s preparation may take weeks, the window between publishing the malicious version and the registry taking it down is almost always just a few hours to a few days. Out of ten high-profile incidents analyzed, eight had an active compromise window of under a week—the notable outlier being &lt;code&gt;xz-utils&lt;/code&gt; at roughly five weeks.&lt;/p&gt;
&lt;p&gt;A dependency cooldown simply puts a minimum waiting period between when a package version is published and when your tooling considers it eligible for installation, giving the security community time to catch compromises first. Configuring one takes just a couple of lines—such as &lt;code&gt;cooldown: default-days: 7&lt;/code&gt; in Dependabot, or equivalent settings in Renovate and modern package managers. A 7-day cooldown would have blocked almost every attack on the list, and a 14-day cooldown would have stopped all of them except &lt;code&gt;xz-utils&lt;/code&gt;. While it isn&amp;rsquo;t a silver bullet—since supply-chain security is fundamentally a social-trust problem—eliminating 80–90% of the risk at near-zero cost is a no-brainer.&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 #66</title><link>https://miti99.com/en/post/2025/12/09/</link><pubDate>Tue, 09 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I&amp;rsquo;ve used iFlow&amp;rsquo;s free API quite a lot already, so today I&amp;rsquo;m trying out iFlow&amp;rsquo;s CLI—&lt;a href="https://github.com/iflow-ai/iflow-cli" rel="noopener noreferrer"&gt;iFlow CLI&lt;/a&gt;—to see how it goes, using the GLM-4.6 model.&lt;/del&gt; Enjoy Newsletter #66.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-ultimate-list-of-best-software-architecture-books-2026"&gt;&lt;a href="https://www.workingsoftware.dev/the-ultimate-list-of-software-architecture-books/?&amp;amp;aid=recmw058VtqAJCyyK" rel="noopener noreferrer"&gt;The Ultimate List of Best Software Architecture Books (2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Software architecture is the foundation that determines a product&amp;rsquo;s quality: good design reduces bug risk and makes adding features later far easier. Patrick Roos curates a reading list of software architecture books for 2026, spanning classics like Richards and Ford&amp;rsquo;s &lt;em&gt;Fundamentals of Software Architecture&lt;/em&gt;, &lt;em&gt;Software Architecture in Practice&lt;/em&gt; (4th edition), &lt;em&gt;Designing Data-Intensive Applications&lt;/em&gt;, and &lt;em&gt;Enterprise Integration Patterns&lt;/em&gt;, as well as modern practical guides like &lt;em&gt;Software Architecture: The Hard Parts&lt;/em&gt; on distributed-systems trade-offs and &lt;em&gt;Building Multi-Tenant SaaS Architectures&lt;/em&gt; for cloud platforms.&lt;/p&gt;
&lt;p&gt;The list also emphasizes the human and organizational side of architecture: Susanne Kaiser&amp;rsquo;s &lt;em&gt;Architecture for Flow&lt;/em&gt; combines Wardley Mapping, Domain-Driven Design, and Team Topologies to align business strategy with architecture; Gregor Hohpe&amp;rsquo;s &lt;em&gt;The Software Architect Elevator&lt;/em&gt; helps architects bridge the gap between engineering and the business; &lt;em&gt;Collaborative Software Design&lt;/em&gt; shows how to involve stakeholders in the design process; and &lt;em&gt;Facilitating Software Architecture&lt;/em&gt; and &lt;em&gt;Reviewing Software Systems&lt;/em&gt; (introducing the lightweight LASR architecture review method) help architects and developers collaborate more effectively. The list also highlights two new/upcoming titles for late 2025–2026: Lilienthal and Schwentner&amp;rsquo;s &lt;em&gt;Domain-Driven Transformation&lt;/em&gt;, offering a roadmap for modernizing legacy systems, and Simon Brown&amp;rsquo;s &lt;em&gt;The C4 Model&lt;/em&gt; on communicating software architecture through structured diagrams.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-oct-2025"&gt;&lt;a href="https://ben.stolovitz.com/posts/how_use_ai_oct_2025/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;How I use AI (Oct 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Stolovitz shares how he uses AI—primarily large language models (LLMs)—in his daily work as of October 2025. Coding is where AI has made the biggest difference: he calls GitHub Copilot&amp;rsquo;s autocomplete &amp;ldquo;magical&amp;rdquo; for finishing boilerplate and discovering idiomatic patterns in unfamiliar languages, even if it struggles with complex algorithms. Agent mode is increasingly helpful for larger changes, though it still requires solid tests, clear documentation, and human oversight. For search and research, AI excels at tracking down tip-of-the-tongue articles or explaining general concepts, but falls short when shopping for products or finding academic papers, and remains prone to hallucinating citations or sycophantically validating whatever assumption the user feeds it.&lt;/p&gt;
&lt;p&gt;Summarization and transcription are standout strengths: AI can condense hundreds of pages of documentation or an entire meeting recording in minutes. Conversely, Stolovitz refuses to let AI write for him because he views his blog as personal self-expression; he uses AI only as a tough copy editor to suggest better phrasing, then rewrites the text in his own voice. He is most skeptical of AI-generated visual art and music, finding them lacking in creative depth and genuine human connection.&lt;/p&gt;
&lt;h2 id="stop-vibe-coding-your-unit-tests"&gt;&lt;a href="https://www.andy-gallagher.com/blog/stop-vibe-coding-your-unit-tests/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Stop Vibe Coding Your Unit Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Gallagher warns against handing unit test writing over to LLMs on autopilot. Left to their own devices, LLMs tend to generate far too many tests that merely assert what the code currently does rather than verifying what the code &lt;em&gt;should&lt;/em&gt; do. Given a simple React button component, for instance, Claude Sonnet 4 generated roughly 30 tests spanning ~200 lines, mostly testing trivialities like default rendering, prop passthrough, or HTML attributes that React and the browser already guarantee. Such tests lock the codebase to its current implementation so every refactor breaks a pile of tests, while polluting the agent&amp;rsquo;s context window, degrading semantic code search, and turning pull requests into a slog for teammates to review.&lt;/p&gt;
&lt;p&gt;Gallagher&amp;rsquo;s remedy is intentional, test-by-test authoring: explicitly specify which behavior you want to test, carefully review what the AI generates, and keep test files lean and focused. LLMs still do well on self-contained, algorithmic code, but for everyday product code, what actually needs testing is whether the team is building the right thing. The core principle: fewer, higher-quality tests beat bloated test suites every time.&lt;/p&gt;
&lt;h2 id="game-design-is-simple-actually"&gt;&lt;a href="https://www.raphkoster.com/2025/11/03/game-design-is-simple-actually/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Game design is simple, actually&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raph Koster outlines a systematic 12-step framework for understanding game design. At their core, games are about mastering problems: fun comes from making progress in our ability to predict outcomes, not from surface-level flash. A toy is a system with constraints; add a goal and it becomes a game, centered on a core mechanic—a &amp;ldquo;problem object&amp;rdquo; to be solved. Players interact through loops: an operational loop (act, receive feedback, learn) and a progression loop where situations continually escalate and shift so old strategies stop working. Good feedback must tell players what they can do, what they just did, what happened as a result, and whether they are getting closer to their goal, while difficulty must match their learning curve.&lt;/p&gt;
&lt;p&gt;At the macro level, a game is assembled from smaller sub-games whose loops interlock to form economies and value chains. How a problem is dressed up—through narrative, visuals, audio, and metaphor—strongly shapes the player&amp;rsquo;s experience, making game design a synthetic art form that demands both systems design and experience design. Player motivations vary widely too, which is why no single game appeals to everyone. The individual principles sound simple, but executing all 12 well at the same time is the real challenge.&lt;/p&gt;
&lt;h2 id="architectural-debt-is-not-just-technical-debt"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2025-10-31-architectural-debt-is-not-just-technical-debt/?&amp;amp;aid=recufcl24hU9MXCJC" rel="noopener noreferrer"&gt;Architectural debt is not just technical debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Frederick Van Brabant distinguishes architectural debt from technical debt. While technical debt usually refers to localized shortcuts inside a codebase, architectural debt consists of structural decisions with long-term consequences that reach far beyond code. He breaks architectural debt down across three layers. At the application and infrastructure layer, enterprise architects should focus on integration patterns, overlapping systems, and vendor lock-in, because debt here inflates costs and slows delivery. The business layer involves ownership, governance responsibilities, and outdated processes—where inaccurate documentation can create serious trouble during audits. The strategic layer is the most dangerous: poorly defined capabilities or half-baked framework rollouts plant flawed assumptions across the organization for the next three to five years.&lt;/p&gt;
&lt;p&gt;Enterprise architects have the vantage point and time horizon to spot this kind of debt, but merely raising the alarm isn&amp;rsquo;t enough: they need to build a compelling business case laying out the current state, target state, and business upside backed by concrete numbers to win leadership buy-in. Van Brabant also advises picking your battles wisely: it&amp;rsquo;s fine to tolerate more debt in experimental innovation systems than in systems of record, provided you clean it up once the experiment concludes and secure real resources to pay the debt down.&lt;/p&gt;
&lt;h2 id="the-search-problem-why-your-computer-finds-things-faster-than-you-do"&gt;&lt;a href="https://deyaa1251.github.io/deyaa1251/posts/b_tree/?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;The Search Problem: Why Your Computer Finds Things Faster Than You Do&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why B-trees are so foundational in modern storage systems. The author recounts implementing a binary search tree (BST) from scratch and watching it fall apart once simulated disk reads and writes were introduced. A BST&amp;rsquo;s lookup cost scales with its height: O(log n) when balanced, but degrading to O(n) when unbalanced. Under a model where each node visit costs one disk read, searching across 100,000 files takes roughly 17 disk reads with a balanced BST, whereas a B-tree needs only 3. That&amp;rsquo;s because a B-tree packs many keys into each node (&amp;ldquo;fat nodes&amp;rdquo;) sized to fit a single 4KB disk block, keeping the tree extremely shallow. In the author&amp;rsquo;s simulation, inserting 100,000 sequential items caused the BST to degenerate into a 40,000-level linked list that took roughly 23.5 minutes, while the B-tree stayed 3 levels tall and finished in 3 seconds.&lt;/p&gt;
&lt;p&gt;Because they guarantee predictable worst-case performance regardless of insertion order, B-trees and their variants power indexes in MySQL, PostgreSQL, MongoDB, and countless filesystems. The broader lesson extends beyond data structures: hardware context dictates optimal design. B-trees trade away theoretical best-case simplicity in exchange for rock-solid worst-case guarantees—which is what matters in production systems.&lt;/p&gt;
&lt;h2 id="kafka-is-fast"&gt;&lt;a href="https://topicpartition.io/blog/postgres-pubsub-queue-benchmarks?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;Kafka is fast &amp;ndash; I&amp;rsquo;ll use Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks PostgreSQL as a pub/sub and job queue system in place of dedicated message brokers like Kafka. With 1 KiB messages in a pub/sub workload, a 4-vCPU instance in the author&amp;rsquo;s test setup achieved roughly 5,000 messages per second on writes (4.8 MiB/s) and 24.6 MiB/s on reads with a 5x fan-out, at a 60ms p99 latency. A three-node replicated cluster maintained the same throughput while increasing p99 latency to 186ms. Scaling up to a 96-vCPU instance reached 238 MiB/s on writes and 1.16 GiB/s on reads while using only about 10% CPU. In a work-queue pattern, the 4-vCPU machine handled roughly 2.81 MiB/s at a 17.7ms p99 latency, while the 96-vCPU machine reached 19.7 MiB/s.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s takeaway is simple: use Postgres until you genuinely outgrow it. For the vast majority of organizations operating below a few megabytes per second, Postgres covers 80% of use cases with 20% of the effort, whereas the operational overhead and organizational complexity of adopting a separate distributed broker usually outweigh its benefits at modest scale. That simplicity and reliability are exactly why the &amp;ldquo;Just Use Postgres&amp;rdquo; movement keeps gaining traction.&lt;/p&gt;
&lt;h2 id="you-need-to-become-a-full-stack-person"&gt;&lt;a href="https://den.dev/blog/full-stack-person/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;You Need To Become A Full Stack Person&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Den Delimarsky argues that in the AI era, everyone needs to become a &amp;ldquo;full-stack person.&amp;rdquo; As LLMs commoditize many narrow coding skills, combining creativity, critical thinking, and execution speed becomes the durable career moat. Boundaries between traditional roles are blurring, reflected in the rise of the product engineer who owns frontend, backend, and customer empathy end to end. In Delimarsky&amp;rsquo;s view, the T-shaped skill model (one deep specialty atop a broad base) is obsolete; replacing it is the Pi-shaped model with two deep pillars—product sense and technical craft—resting on broad interdisciplinary knowledge.&lt;/p&gt;
&lt;p&gt;The post highlights ten skills to cultivate: creativity and taste, critical thinking, communication, interdisciplinary breadth, AI leverage, product sense, execution speed, rapid learning, systems thinking, and agency. AI cannot replace taste or judgment; it is a vehicle for turning ideas into reality, lowering the cost of writing code without lowering the cost of deciding what is worth building. Typing code is no longer the bottleneck, and a high-agency &amp;ldquo;start doing, then figure it out&amp;rdquo; mindset is what sets people apart.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;iFlow CLI did a pretty good job on the first few articles, though toward the end it started leaving too many English words untranslated. A nice plus is that iFlow CLI can fetch many URLs by bypassing blocks through a proxy (though it&amp;rsquo;s a Chinese proxy, which feels a bit sketchy). While running it I also saw a bunch of log lines in Chinese, which was confusing and slightly unnerving :v I&amp;rsquo;ll try to refine &lt;code&gt;AGENTS.md&lt;/code&gt; and test it again later.&lt;/em&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 #65</title><link>https://miti99.com/en/post/2025/12/08/</link><pubDate>Mon, 08 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/08/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Lately the free models on OpenRouter have been pretty unstable—sometimes they work, sometimes they don&amp;rsquo;t. Since I still had a few dollars of credit left there, I decided to burn through the rest today before switching over to iFlow full-time (until iFlow stops being free :v).&lt;/del&gt; Enjoy Newsletter #65. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://openrouter.ai" rel="noopener noreferrer"&gt;OpenRouter&lt;/a&gt; &amp;amp; &lt;a href="https://openrouter.ai/anthropic/claude-sonnet-4.5" rel="noopener noreferrer"&gt;Anthropic: Claude Sonnet 4.5&lt;/a&gt; (a &amp;lsquo;premium&amp;rsquo; model hehe)&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="scaling-engineering-teams-lessons-from-google-facebook-and-netflix"&gt;&lt;a href="https://greenido.dev/2025/09/25/scaling-engineering-teams-lessons-from-google-facebook-and-netflix/" rel="noopener noreferrer"&gt;Scaling Engineering Teams: Lessons from Google, Facebook, and Netflix&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ido Green, drawing on more than a decade of engineering leadership at Google, Facebook, and Netflix, argues that when scaling from 10 to over 1,000 engineers, whether an organization thrives or collapses comes down to three pillars: structured goal-setting, an uncompromising focus on code quality, and intentional culture-building. At Google, OKRs are set ambitiously—3–5 objectives per team with 2–4 measurable key results each—where hitting 60–70% is the sweet spot and 100% means the goals weren&amp;rsquo;t ambitious enough. For code quality, Facebook requires every line of code to be reviewed, every part of the codebase to have an owner, and new code to maintain at least 80% test coverage; Netflix proactively injects failures with Chaos Monkey (randomly terminating production instances), runs failure drills, and rolls out canaries to 1% of users first.&lt;/p&gt;
&lt;p&gt;On culture, Google sets aside one afternoon a month for experimentation; Facebook puts new hires through a 6-week Bootcamp where they fix bugs across the stack before choosing a team; and Netflix hires top talent, pays top-of-market compensation, and treats people like adults. Green recommends tracking the four DORA metrics such as deployment frequency and mean time to recovery. The biggest lesson: hero culture, manual processes, and tribal knowledge work at 10 people but become a disaster at 100; what scales are systems, documentation, automation, and clear ownership. Rather than cargo-culting practices, execute consistently and measure what matters.&lt;/p&gt;
&lt;h2 id="the-trap-of-excessive-ai-use"&gt;&lt;a href="https://dpereira.substack.com/p/the-trap-of-excessive-ai-use" rel="noopener noreferrer"&gt;The Trap of Excessive AI Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Pereira, author of &lt;em&gt;Untrapping Product Teams&lt;/em&gt;, warns that overusing AI makes us mediocre rather than better. He isn&amp;rsquo;t anti-AI, but opposes the &amp;ldquo;automate everything&amp;rdquo; mindset—the assumption that if AI can do something, we no longer need to care about it. AI makes us faster, not wiser. He points to troubling habits: delegating prioritization to AI, having AI write PRDs instead of thinking through what actually matters, summarizing everything instead of learning deeply, and replacing real user research with AI-generated insights. Critical thinking, understanding human behavior, and challenging assumptions must remain ours; paradoxically, the more people rush to outsource everything to AI, the more valuable those who don&amp;rsquo;t become.&lt;/p&gt;
&lt;p&gt;Pereira shares his own &amp;ldquo;old-school&amp;rdquo; habits—reading every message himself, writing his own emails to give himself time to think, reading whole books cover to cover, taking handwritten notes, and single-tasking—viewing them as a competitive edge. Still, AI is great for accelerating low-value work (drafting meeting notes, summarizing competitor features), exploring alternatives and stress-testing assumptions, tailoring messaging for different audiences, and brainstorming experiment ideas to learn faster. His rule of thumb is &amp;ldquo;AI can draft, but I decide&amp;rdquo;: delegate tasks, never ownership, because letting AI decide crosses the line from leveraging a tool to abdicating responsibility.&lt;/p&gt;
&lt;h2 id="how-google-amazon-and-crowdstrike-broke-millions-of-systems"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/how-google-amazon-and-crowdstrike" rel="noopener noreferrer"&gt;How Google, Amazon, and CrowdStrike Broke Millions of Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Milan Milanović dissects three massive outages showing how even simple bugs can turn catastrophic at hyperscale. In October 2025, a race condition in DynamoDB&amp;rsquo;s automated DNS management in &lt;code&gt;us-east-1&lt;/code&gt; caused a 15-hour AWS outage across 113 services: a delayed DNS Enactor overwrote Route 53 with a stale plan right as another Enactor cleaned up &amp;ldquo;expired&amp;rdquo; plans, wiping out the DNS records entirely—a classic time-of-check to time-of-use (TOCTOU) bug. DNS was restored after about 3 hours, but cascading failures dragged on for another 12. In June 2025, Google Cloud went down for roughly 7 hours: new code in Service Control, the gateway for every API call, lacked a null check and wasn&amp;rsquo;t gated behind a feature flag; it lay dormant for 14 days until a policy with a blank field was replicated globally via Spanner in seconds.&lt;/p&gt;
&lt;p&gt;The third outage struck in July 2024: Channel File 291 triggered an out-of-bounds array read inside CrowdStrike&amp;rsquo;s kernel-mode interpreter, sending 8.5 million Windows machines into boot loops that had to be fixed manually in Safe Mode one machine at a time. Across all three incidents, speed was prioritized over safety, single points of failure had massive blast radii, and automated recovery mechanisms themselves became failure amplifiers. The takeaways: use atomic state transitions, add circuit breakers and jittered backoff to recovery loops, roll out changes in stages with canaries, validate data before global replication, and test configuration with the same rigor as code.&lt;/p&gt;
&lt;h2 id="the-linux-boot-process-from-power-button-to-kernel"&gt;&lt;a href="https://www.0xkato.xyz/linux-boot/" rel="noopener noreferrer"&gt;The Linux Boot Process: From Power Button to Kernel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post walks clearly through how Linux boots on x86 hardware, from pressing the power button to the kernel&amp;rsquo;s entry point, focusing primarily on the traditional BIOS flow (UEFI or alternative bootloaders skip some of these steps). When power comes on, the CPU resets into 16-bit real mode—a legacy of the original 8086—and jumps to the reset vector at &lt;code&gt;0xFFFFFFF0&lt;/code&gt;, where firmware places a jump instruction into its own initialization code. Legacy BIOS scans disks for a 512-byte boot sector ending in &lt;code&gt;0x55&lt;/code&gt; &lt;code&gt;0xAA&lt;/code&gt;, whereas modern UEFI understands filesystems and loads larger boot binaries directly. A bootloader like GRUB loads the kernel image into memory, populates the setup header, and hands control to the kernel&amp;rsquo;s setup code. That code establishes a predictable environment: normalizing segment registers, setting up a stack, zeroing the BSS section, and querying firmware for the system memory map via the &lt;code&gt;e820&lt;/code&gt; BIOS interrupt. Next come two mode transitions: into 32-bit protected mode (disabling interrupts, enabling the A20 line, loading minimal GDT and IDT tables, and setting the PE bit in &lt;code&gt;CR0&lt;/code&gt;), and then into 64-bit long mode (enabling PAE in &lt;code&gt;CR4&lt;/code&gt;, building identity-mapped page tables, loading their address into &lt;code&gt;CR3&lt;/code&gt;, and setting the LME bit in &lt;code&gt;EFER&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;Once in 64-bit mode, &lt;code&gt;extract_kernel&lt;/code&gt; decompresses the kernel image (&lt;code&gt;gzip&lt;/code&gt;, &lt;code&gt;xz&lt;/code&gt;, &lt;code&gt;zstd&lt;/code&gt;, etc.), parses the ELF header to place code and data sections, applies relocations if the kernel isn&amp;rsquo;t loaded at its default address, and jumps into &lt;code&gt;start_kernel&lt;/code&gt;. The article also explains kASLR: the decompressor picks random physical and virtual base addresses within available memory ranges—carefully avoiding occupied regions like &lt;code&gt;initrd&lt;/code&gt;—making it much harder for attackers to guess where kernel code lives, and falling back to the default address if no suitable slot is found. Complete with a glossary, it&amp;rsquo;s an approachable primer for newcomers.&lt;/p&gt;
&lt;h2 id="build-system-tradeoffs"&gt;&lt;a href="https://jyn.dev/build-system-tradeoffs" rel="noopener noreferrer"&gt;Build System Tradeoffs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;jyn, who works on the build system for the Rust compiler, kicks off a series on build systems with a survey of what complex builds actually have to juggle: running binaries that were just built as part of the build itself (like integration tests invoking &lt;code&gt;cargo build&lt;/code&gt; inside &lt;code&gt;cargo test&lt;/code&gt;), accurate dependency tracking, cross-compilation (requiring compilers, standard libraries, and linkers for both host and target platforms), choosing between dynamic and static linking, and reproducible builds—a prerequisite for safe caching. According to the author, the most common mistake is forcing build configuration into a restrictive custom DSL: purely &amp;ldquo;declarative&amp;rdquo; builds are an illusion, so it&amp;rsquo;s far better to express build logic in a real programming language and serialize the resulting build graph into a minimal format like Ninja.&lt;/p&gt;
&lt;p&gt;For dependency tracking, there are four main approaches. Manual declarations—even with compiler assistance like &lt;code&gt;gcc -M&lt;/code&gt;—are error-prone. Always rebuilding from scratch is guaranteed correct but slow. Hermetic builds like Bazel, Buck2, and Nix restrict steps to explicitly declared inputs, unlocking safe remote caching. Tracing builds like Tup and Ekam discover dependencies automatically by intercepting syscalls, requiring zero manual declarations, but mostly only work on Linux and struggle to scale because the graph isn&amp;rsquo;t known upfront. The author concludes that prioritizing correctness always comes with trade-offs, combining syscall tracing with hermetic sandboxing looks like the sweet spot, and writing build rules in a general-purpose language that compiles down to a serialized graph has surprisingly few downsides.&lt;/p&gt;
&lt;h2 id="how-i-use-every-claude-code-feature"&gt;&lt;a href="https://blog.sshh.io/p/how-i-use-every-claude-code-feature" rel="noopener noreferrer"&gt;How I Use Every Claude Code Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar shares how he uses nearly every feature of Claude Code in practice. The most important foundation is the root &lt;code&gt;CLAUDE.md&lt;/code&gt; file—the agent&amp;rsquo;s &amp;ldquo;constitution&amp;rdquo;: at his company, it is capped at 13KB and documents only tools used by at least 30% of engineers. He advises starting with guardrails based on mistakes Claude actually makes rather than writing an exhaustive manual, avoiding &lt;code&gt;@&lt;/code&gt;-mention file embeds because they bloat context, and never writing a negative rule without providing the preferred alternative. Within the 200k-token context window, he avoids &lt;code&gt;/compact&lt;/code&gt; because it&amp;rsquo;s opaque and lossy, preferring &lt;code&gt;/clear&lt;/code&gt; paired with a custom &lt;code&gt;/catchup&lt;/code&gt; command that re-reads changed files, or having Claude dump progress to a &lt;code&gt;.md&lt;/code&gt; file before starting a fresh session. He avoids custom subagents because they hide context and force the agent into rigid human workflows; instead, the main agent uses &lt;code&gt;Task(...)&lt;/code&gt; to spawn clones of itself—a pattern he calls &amp;ldquo;Master-Clone.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Hooks are invaluable in enterprise repos: blocking commits when tests haven&amp;rsquo;t passed, paired with non-blocking suggestion hooks, while avoiding block-at-write hooks that confuse the agent mid-task. Echoing Simon Willison, he argues Skills may matter more than MCP because they formalize the &amp;ldquo;scripting&amp;rdquo; paradigm—the evolutionary step after single prompts and tool calling—leaving MCP as a narrow security gateway for stateful environments like Playwright. Finally, the most underrated feature is the Claude Code GitHub Action: full container control, tight sandboxing, and complete audit logs that can be mined periodically to improve &lt;code&gt;CLAUDE.md&lt;/code&gt; and developer tooling.&lt;/p&gt;
&lt;h2 id="if-you-don"&gt;&lt;a href="https://seated.ro/blog/tinkering-a-lost-art" rel="noopener noreferrer"&gt;If you don&amp;rsquo;t tinker, you don&amp;rsquo;t have taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;seatedro writes about &amp;ldquo;tinkering&amp;rdquo;—poking at small things and tweaking them just to see how they can be improved—as a lifelong learning tool. The author tried everything from guitar and art to martial arts, yet didn&amp;rsquo;t start tinkering with programming until relatively late; once it clicked, it became central to how they learn, and they wish they had started sooner. Tinkering means spending hours dialing in mouse sensitivity in a game, losing days configuring a Linux window manager just for fun, or taking apart a mechanical keyboard to swap keycaps and test switches. Some people only do things that serve a concrete goal, while others do things &amp;ldquo;just because&amp;rdquo;; the ideal is combining both. The author quotes &lt;code&gt;@ludwigABAP&lt;/code&gt; that tinkering and throwing the result away is practice, and practice should be ephemeral, exploratory, and frequent.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, using Git from the command line instead of GitHub Desktop or knowing basic Vim motions should be baseline literacy rather than a rarity, though balance still matters: the last time they tweaked their Neovim config was six months ago. In a single week, the author wrote their first GLSL fragment shader, Rust procedural macro, C++ template, and Swift app, and tried out the Helix editor—none of it strictly necessary. The core message is that &amp;ldquo;taste&amp;rdquo;—the ability to tell mediocrity from excellence—only develops when you try lots of things, keep what resonates, and discard what doesn&amp;rsquo;t; so question defaults, experiment, and break things every day.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals 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://substackcdn.com/image/fetch/$s_!Fxka!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F60f07f90-6f22-4b1f-ab2e-d98e8ccc755a_3000x3900.png" alt="10 Key Data Structures We Use Every Day"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Nizo!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fffa24eaf-4fc7-4278-a0df-faddb41c765f_2048x2662.png" alt="IP Address Cheat Sheet Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ZdF6!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fef416976-ae0f-48f5-86e1-0189c0b9be88_2360x2664.png" alt="Which Protocols Run on TCP and UDP"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;Whoa, it hit the credit limit right while processing the last URL. I started with $2 (around 52k VND) and it only processed 7 URLs, which comes out to ~7.5k VND per article. Pretty steep :v And the output still wasn&amp;rsquo;t quite what I wanted, since it still overused English terms—you can clearly see that in the last summary. It might be an issue with my &lt;code&gt;AGENTS.md&lt;/code&gt; file, so I&amp;rsquo;ll optimize that later. Either way, I achieved my goal of burning through the remaining credit so I can go back to using free tiers :v See you in upcoming posts :D.&lt;/em&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 #62</title><link>https://miti99.com/en/post/2025/12/02/</link><pubDate>Tue, 02 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #62. &lt;del&gt;This post was created using VSCode Chat + OpenRouter + xAI: Grok 4.1 Fast (free)&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="claude-skills-are-awesome-maybe-a-bigger-deal-than-mcp"&gt;&lt;a href="https://simonwillison.net/2025/Oct/16/claude-skills/" rel="noopener noreferrer"&gt;Claude Skills are awesome, maybe a bigger deal than MCP&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this October 2025 post, Simon Willison introduces Anthropic&amp;rsquo;s &lt;strong&gt;Claude Skills&lt;/strong&gt;, a simple mechanism for giving models new capabilities: each skill is a directory containing a Markdown file that instructs the model how to perform a task, accompanied by supporting docs and pre-written scripts when needed. What makes it a real feature is that at the start of a session, Claude only reads the short description in each skill&amp;rsquo;s YAML frontmatter (a few dozen tokens per skill) and loads the full content only when the user&amp;rsquo;s request actually needs it. Willison tests the &lt;strong&gt;slack-gif-creator&lt;/strong&gt; skill to generate a GIF comparing Skills with MCP: Claude writes a Python script using PIL to build the animation, then calls a validation helper bundled with the skill to ensure the file stays under Slack&amp;rsquo;s 2MB limit. The first GIF was rough, but the skill made iterating easy.&lt;/p&gt;
&lt;p&gt;Skills depend entirely on a code execution environment with a filesystem and shell access, such as Claude Code, Codex CLI, or Gemini CLI—the biggest difference between Skills and MCP or ChatGPT Plugins. In Willison&amp;rsquo;s view, Claude Code is actually a general-purpose agent: a folder of Markdown files describing how to fetch census data, load it into SQLite or DuckDB, export Parquet, and visualize it with D3 is enough to turn it into a data-journalism agent. Compared to MCP, which burns tens of thousands of tokens just describing tools and carries a complex protocol specification, Skills are just Markdown plus a bit of metadata, easy to share and portable across models. That simplicity is their superpower.&lt;/p&gt;
&lt;h2 id="environment-variables-are-a-legacy-mess-let"&gt;&lt;a href="https://allvpv.org/haotic-journey-through-envvars/" rel="noopener noreferrer"&gt;Environment variables are a legacy mess: Let&amp;rsquo;s dive deep into them&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Environment variables are a legacy Unix interface that remains the default way to pass runtime configuration to applications: a flat, global string dictionary with no namespaces or data types. They are passed from parent process to child process via the &lt;code&gt;execve&lt;/code&gt; syscall with three parameters—&lt;code&gt;filename&lt;/code&gt;, &lt;code&gt;argv&lt;/code&gt;, and &lt;code&gt;envp&lt;/code&gt;; by default, almost every tool forwards the entire environment, apart from exceptions like &lt;code&gt;login&lt;/code&gt; that initialize a fresh one. At startup, the kernel places the variables on the stack as null-terminated strings, and each program copies them into its own internal data structure: Bash uses a stack of hashmaps (allowing &lt;code&gt;local&lt;/code&gt; variables to be &lt;code&gt;export&lt;/code&gt;ed), glibc uses a dynamic array that makes &lt;code&gt;getenv&lt;/code&gt; and &lt;code&gt;putenv&lt;/code&gt; linear-time operations, and Python&amp;rsquo;s &lt;code&gt;os.environ&lt;/code&gt; syncs only one way down to the C library&amp;rsquo;s &lt;code&gt;putenv&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The kernel itself is remarkably permissive about format: it accepts duplicate names, strings without an &lt;code&gt;=&lt;/code&gt;, and even emoji. On Linux with 4 KiB pages, each string is typically capped at 128 KiB, while the total size depends on stack limits rather than a fixed 2 MiB across all machines. Bash strips duplicate and malformed entries, while names containing whitespace (which Nushell and Python handle fine) are kept in Bash&amp;rsquo;s &lt;code&gt;invalid_env&lt;/code&gt; table and still forwarded to child processes. Contrary to popular belief, POSIX only requires that names not contain &lt;code&gt;=&lt;/code&gt; and actually recommends lowercase names to avoid colliding with standard utilities, even though convention strongly favors uppercase. The author advises sticking to &lt;code&gt;^[A-Z_][A-Z0-9_]*$&lt;/code&gt; names and UTF-8 values.&lt;/p&gt;
&lt;h2 id="examples-are-the-best-documentation"&gt;&lt;a href="https://rakhim.exotext.com/examples-are-the-best-documentation" rel="noopener noreferrer"&gt;Examples are the best documentation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that examples are the single most useful form of documentation: 95% of the time you look something up, a simple example is all you need, yet official docs rarely include one. Technical documentation is often written for people already immersed in the ecosystem, whereas working developers constantly jump between projects, languages, and frameworks, paying a context-restoration tax every time. For instance, the signature &lt;code&gt;max(iterable, /, *, key=None)&lt;/code&gt; in Python&amp;rsquo;s docs requires understanding &lt;code&gt;*&lt;/code&gt;, &lt;code&gt;/&lt;/code&gt;, positional-only parameters, iterables, and keyword-only parameters, whereas a few lines of examples immediately answer the most common questions:&lt;/p&gt;
&lt;pre tabindex="0"&gt;&lt;code&gt;max(4, 6) # → 6
max([1, 2, 3]) # → 3
max([&amp;#39;x&amp;#39;, &amp;#39;y&amp;#39;, &amp;#39;abc&amp;#39;], key=len) # → &amp;#39;abc&amp;#39;
max([]) # ValueError
max([], default=5) # → 5
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Clojure&amp;rsquo;s community-driven &lt;code&gt;clojuredocs.org&lt;/code&gt; is a model here: users contribute examples for built-in functions, often combining related functions (like &lt;code&gt;into&lt;/code&gt;, &lt;code&gt;spit&lt;/code&gt;, and &lt;code&gt;map&lt;/code&gt;) to make examples realistic. Because few projects maintain all four types of documentation, the author often hesitates to click a &amp;ldquo;Documentation&amp;rdquo; link for fear of landing on a dry, auto-generated API reference; instead, he searches for tutorials—not for step-by-step hand-holding, but just to find concrete code examples.&lt;/p&gt;
&lt;h2 id="hazardous-states-and-accidents"&gt;&lt;a href="https://entropicthoughts.com/hazardous-states-and-accidents" rel="noopener noreferrer"&gt;Hazardous States and Accidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post introduces a foundational concept from safety-critical systems engineering: distinguishing &lt;strong&gt;accidents&lt;/strong&gt; (actual harm) from &lt;strong&gt;hazardous states&lt;/strong&gt;. An accident occurs only when a system is in a hazardous state and encounters adverse environmental conditions (H ∧ E ⇔ A); because we can control our system but not the environment, safety is achieved by keeping the system out of hazardous states. In the author&amp;rsquo;s example, an aircraft landing with less than 30 minutes of fuel reserve is in a hazardous state even if nothing bad happens on that flight, because bad weather is all it would take to turn it into an accident; similarly, a child cannot promise &amp;ldquo;not to fall,&amp;rdquo; but can promise not to stand right on the edge of a cliff without someone spotting them below.&lt;/p&gt;
&lt;p&gt;Enforcing safety constraints is a dynamic control problem: multiple controllers observe feedback about the current state, use a mental model to predict future states, and issue corrective actions; a system enters a hazardous state when any of those three elements falls short, including when corrective action is too weak or too aggressive. Controllers exist at every layer, from the engine&amp;rsquo;s FADEC and the pilots to air traffic control and regulators. Predicting hazardous states is far easier than predicting accidents, which is why organizations must analyze near misses instead of waiting for actual accidents—something aviation excels at but software engineering often neglects.&lt;/p&gt;
&lt;h2 id="multi-core-by-default"&gt;&lt;a href="https://www.dgtlgrove.com/p/multi-core-by-default" rel="noopener noreferrer"&gt;Multi-Core By Default&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ryan Fleury argues that multi-core programming should be the default rather than a special optimization bolted onto single-threaded code, because modern CPUs have 8, 16, 32, or 64 cores and ignoring them leaves massive performance on the table. Familiar approaches like &amp;ldquo;parallel for&amp;rdquo; or job systems carry real costs: spawning threads through the kernel or dispatching tasks to a thread pool, manually slicing up work, scattering control flow across cores and time in ways that complicate debugging, and tangling resource lifetimes. Inspired by GPU shaders, Fleury flips the model: spin up a fixed set of threads (&amp;ldquo;lanes&amp;rdquo;) upfront that all enter the same &lt;code&gt;EntryPoint&lt;/code&gt; function together, using &lt;code&gt;LaneIdx()&lt;/code&gt;, &lt;code&gt;LaneCount()&lt;/code&gt;, and &lt;code&gt;LaneSync()&lt;/code&gt; to partition work evenly and synchronize across barriers.&lt;/p&gt;
&lt;p&gt;To sum an array, each lane uses &lt;code&gt;LaneRange&lt;/code&gt; to claim a slice of elements, computes a local sum, and folds it into a shared total with an atomic add. Operations that must run serially—such as reading a file or printing output—are narrowed to a single lane with &lt;code&gt;if (LaneIdx() == 0)&lt;/code&gt;, which then broadcasts results (such as a buffer pointer) to all other lanes via &lt;code&gt;LaneSyncU64&lt;/code&gt;. Uneven workloads can pull tasks from a shared atomic counter or switch to more uniform algorithms, such as radix sort instead of comparison-based sorting. This style requires less machinery, is easier to debug because every lane shares the same full call stack, and still runs cleanly on a single core simply by setting the lane count to 1. The author uses this architecture in building his debugger.&lt;/p&gt;
&lt;h2 id="vibing-a-non-trivial-ghostty-feature"&gt;&lt;a href="https://mitchellh.com/writing/non-trivial-vibing" rel="noopener noreferrer"&gt;Vibing a Non-Trivial Ghostty Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mitchell Hashimoto walks through his end-to-end process of using agentic coding (with Amp) to build an unobtrusive macOS update notification pill for Ghostty. He planned the architecture himself before touching AI: customize the Sparkle update framework&amp;rsquo;s UI and place a small pill button in the titlebar. In the first session, he asked the agent to plan and prototype the SwiftUI view; the result was on the right track but hit a tab-bar layout conflict that neither the agent nor Hashimoto could cleanly fix, prompting him to pivot to an overlay in the bottom-right corner of the window—which was also needed for hidden-titlebar configurations anyway. On the backend, he stubbed out function skeletons with TODO comments for the agent to fill in, but had to throw that attempt away because the design was flawed; only after he manually refactored the view model into a tagged union did subsequent agent sessions produce solid results.&lt;/p&gt;
&lt;p&gt;His workflow consists of planning with the &amp;ldquo;oracle,&amp;rdquo; breaking work into small pieces, dedicating separate sessions to cleanup, documentation, and refactoring, building a mock driver to test update flows, wiring backend to frontend, and finally asking the agent what else could be improved. He emphasizes that hand-written scaffolding and thorough human review before merging are non-negotiable—never ship code you don&amp;rsquo;t understand. Across 16 sessions, $15.98 in token costs, and roughly 8 hours of wall-clock work, he found the process faster than doing it all by hand—especially when tweaking SwiftUI visuals—while letting the AI make progress while he stepped away for other tasks.&lt;/p&gt;
&lt;h2 id="bonus-an-interesting-visual-from-bytebytego"&gt;Bonus: An interesting visual 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://substackcdn.com/image/fetch/$s_!lKZF!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fde422306-ef24-4d81-ac91-cb24ff284706_2250x2624.heic" alt="A Guide to Microservices Architecture for Building Scalable Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;I&amp;rsquo;d rate the output from this combo around 4–6/10: the structure is decent and it captures the core points, though it still leaves a lot of English terms untranslated. The upside is that it&amp;rsquo;s built right into VSCode, taking advantage of VSCode&amp;rsquo;s built-in features without needing to run an extra terminal.&lt;/em&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 #59</title><link>https://miti99.com/en/post/2025/10/03/</link><pubDate>Fri, 03 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #59.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="taking-a-look-at-compression-algorithms"&gt;&lt;a href="https://cefboud.com/posts/compression/" rel="noopener noreferrer"&gt;Taking a Look at Compression Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Moncef Abboud&amp;rsquo;s article dives into four popular lossless compression algorithms—GZIP (DEFLATE), Snappy, LZ4, and ZSTD—framed around the three metrics every compression algorithm must balance: compression ratio, compression speed, and decompression speed. DEFLATE combines LZ77 sliding-window matching, which replaces repeated sequences with back-references, and Huffman coding, which assigns shorter codes to frequent symbols. Walking through Go&amp;rsquo;s standard library implementation, the author shows how a chained hash table finds matching substrings and how the compression level essentially controls how deep down that chain the compressor searches: searching longer burns more CPU but yields a higher compression ratio.&lt;/p&gt;
&lt;p&gt;Snappy and LZ4 both belong to the LZ family but prioritize speed: Snappy compresses at 250 MB/s and up, while LZ4 reaches roughly 780 MB/s for compression and nearly 5 GB/s for decompression at a similar ratio (~2.1x), thanks to a simple block format using a 4-bit token layout for literal and match lengths plus hardware-friendly XOR comparisons. ZSTD achieves the best of both worlds: a ~2.9x compression ratio matching or beating DEFLATE alongside a ~510 MB/s compression speed approaching LZ4, by combining LZ-style matching with modern FSE entropy coding (based on ANS) and support for pre-trained dictionaries. No single algorithm wins everywhere: DEFLATE suits general archival, Snappy and LZ4 fit speed-critical systems, and ZSTD is the balanced all-rounder.&lt;/p&gt;
&lt;h2 id="90"&gt;&lt;a href="https://lucumr.pocoo.org/2025/9/29/90-percent/" rel="noopener noreferrer"&gt;90%&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher shares that for an infrastructure component he started at his new company, over 90% of the code was written by AI. It is a Go service for sending and receiving emails, complete with an OpenAPI-compatible REST API and SDKs for Python and TypeScript, totaling around 40,000 lines of code. Even so, he treats every line as his own responsibility: he designed the system, database schema, and architecture himself, using AI only as a &amp;ldquo;rubber duck&amp;rdquo; sparring partner. AI allowed him to pursue choices that used to be too tedious to do by hand, such as writing raw SQL instead of using an ORM for easier debugging, or making the OpenAPI spec the single source of truth and generating both client and server code from it. He uses Claude Code for debugging and Codex for code review.&lt;/p&gt;
&lt;p&gt;Ronacher is equally candid about the downsides: left unchecked, AI agents write terrible code, reinvent existing utilities, build abstractions at the wrong scale, fail to truly grasp Go concurrency with goroutines, pull in outdated dependencies, and swallow errors in ways that hurt observability. For example, an AI-written rate limiter &amp;ldquo;worked&amp;rdquo; but lacked jitter and had poor storage design—easy to fix if you understand the domain, dangerous if you don&amp;rsquo;t. Conversely, AI shines at rapid research-and-prototyping loops, continuous refactoring, spinning up AWS infrastructure, or migrating a test suite to testcontainers in an hour. His conclusion: 90% AI-written code is already a reality, but it doesn&amp;rsquo;t eliminate the need to be a strong engineer.&lt;/p&gt;
&lt;h2 id="the-weird-concept-of-branchless-programming"&gt;&lt;a href="https://sanixdk.xyz/blogs/the-weird-concept-of-branchless-programming" rel="noopener noreferrer"&gt;The Weird Concept of Branchless Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Branchless programming is the technique of rewriting conditional statements into arithmetic and bitwise operations, or using conditional move instructions like &lt;code&gt;cmov&lt;/code&gt;, so the CPU doesn&amp;rsquo;t have to guess which branch will be taken. Modern CPU branch predictors perform remarkably well when conditions follow a pattern, but with unpredictable data like user input or shuffled arrays, every misprediction forces a pipeline flush and costs roughly 15–20 cycles. Branchless code runs more consistently and often has more predictable execution time, which matters in cryptography to defend against side-channel attacks—though removing branches alone does not guarantee constant time, as memory access patterns, compiler optimizations, and machine instructions must still be verified.&lt;/p&gt;
&lt;p&gt;The author illustrates this with three C examples of increasing complexity: computing an absolute value using a bitmask derived from a 31-bit arithmetic right shift, a &lt;code&gt;clamp&lt;/code&gt; function that bounds a value between min and max without an &lt;code&gt;if&lt;/code&gt;, and a quicksort &lt;code&gt;partition&lt;/code&gt; function that increments the index directly using the comparison result. Benchmarks show that &lt;code&gt;abs&lt;/code&gt; and &lt;code&gt;clamp&lt;/code&gt; are barely any faster because the branch predictor already handles them well; only &lt;code&gt;partition&lt;/code&gt;, with its unpredictable condition, sees a ~1.2x speedup. The takeaway: branchless programming is a &amp;ldquo;scalpel, not a sledgehammer&amp;rdquo;—use it for hot loops with unpredictable branches, timing-sensitive code, or SIMD vectorization, and stick to plain &lt;code&gt;if&lt;/code&gt; statements when readability matters more than a few nanoseconds.&lt;/p&gt;
&lt;h2 id="ai-coding-assistants-building-apps-for-30-hours-straight"&gt;&lt;a href="https://threadreaderapp.com/thread/1972793278744461627.html" rel="noopener noreferrer"&gt;AI Coding Assistants: Building Apps for 30 Hours Straight&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an X thread, Carlos E. Perez (@IntuitMachine) analyzes the leaked system prompt of Claude Sonnet 4.5 to explain how the model can work autonomously for roughly 30 hours straight to build a Slack-like application with over 10,000 lines of code. According to Perez, the secret lies in forcing any code snippet longer than about 20 lines into a persistent artifact—at most one artifact per response—paired with clear rules for when to make targeted updates versus when to rewrite the file from scratch. This lets the model evolve a large codebase across many turns without losing state. The prompt also enforces runtime constraints such as banning &lt;code&gt;localStorage&lt;/code&gt; and restricting how libraries are imported so UI previews remain stable inside the sandbox.&lt;/p&gt;
&lt;p&gt;Alongside this are patterns that sustain long-horizon autonomy: a research mode that plans, searches, and synthesizes answers; using tools to verify facts rather than guessing; separating thinking from acting to prevent premature coding; planning and feedback loops inspired by Voyager and Generative Agents; passing full conversation state on every call; and a &amp;ldquo;failure ritual&amp;rdquo; that clears stale context and retries with lessons learned. Favoring familiar stacks like React and Flask and keeping outputs in JSON for automated testing also prevent multi-hour sessions from collapsing under their own complexity.&lt;/p&gt;
&lt;h2 id="development-gets-better-with-age"&gt;&lt;a href="https://www.allthingsdistributed.com/2025/10/better-with-age.html" rel="noopener noreferrer"&gt;Development Gets Better with Age&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After nearly 25 years at Amazon, Werner Vogels reflects on the advantages of older developers. They have already encountered most of the problems younger engineers are facing today, carry battle scars from war rooms, know what is practical and effective, and are trained to spot warning signs early. That frees up mental bandwidth for creativity, building mental models, and finding novel solutions—which he considers the best part of the craft. They have also watched industry patterns repeat over and over, including vendors that promise the moon and deliver products riddled with holes.&lt;/p&gt;
&lt;p&gt;On generative AI, Vogels acknowledges that it is an exciting, powerful technology in the hands of experienced builders with healthy skepticism, but notes that the hype wave exploded because it arrived without an instruction manual. AWS responded by returning to its roots: democratizing access, giving customers model choice, and putting privacy and security first. When customers ask what they should do with generative AI, it is mostly driven by FOMO rather than a concrete problem. That is when seasoned developers know to hit pause, talk deeply with the customer to uncover the real challenge, and recognize that only sometimes is generative AI the right answer. As he puts it: new technology, same old patterns.&lt;/p&gt;
&lt;h2 id="programming-deflation"&gt;&lt;a href="https://tidyfirst.substack.com/p/programming-deflation" rel="noopener noreferrer"&gt;Programming Deflation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck starts from the premise that AI-assisted programming is steadily driving down the cost, skill barrier, and time required to build software, and asks: will this lead to fewer programmers or more? Economics offers two opposing answers: the substitution effect says machines will replace people, while Jevons paradox predicts demand will surge when a resource becomes cheaper. If writing software tomorrow is even cheaper than today, organizations might delay investment, much like a deflationary spiral. Unlike economic deflation, however—which reflects weakness—&amp;ldquo;programming deflation&amp;rdquo; comes from real productivity gains: when the cost of experimentation approaches zero, people want to try ideas immediately; low-quality code floods the market while the gap to carefully crafted software widens; and value shifts from writing code to understanding what to build and how systems fit together.&lt;/p&gt;
&lt;p&gt;Beck&amp;rsquo;s advice is to use cheap tools for the obvious parts and save your energy for hard problems, focus on integration since typing code is no longer the bottleneck, cultivate &amp;ldquo;taste&amp;rdquo; to know what is worth building, and think in systems. In a world of abundant code, the scarce resources are understanding, judgment, and the wisdom to know what not to do. Those qualities remain valuable whether the future holds fewer programmers or more, so instead of trying to predict which scenario wins, build skills that thrive in both.&lt;/p&gt;
&lt;h2 id="what-is"&gt;&lt;a href="https://www.seangoedecke.com/taste/" rel="noopener noreferrer"&gt;What is &amp;ldquo;good taste&amp;rdquo; in software engineering?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke distinguishes &amp;ldquo;technical taste&amp;rdquo; from technical skill: you can be highly skilled with bad taste, or vice versa. In his view, taste is the ability to choose the right set of engineering values for the project at hand. For instance, he prefers &lt;code&gt;map&lt;/code&gt; and &lt;code&gt;filter&lt;/code&gt; over &lt;code&gt;for&lt;/code&gt; loops because pure functions are easier to reason about and avoid off-by-one errors, whereas someone who prefers &lt;code&gt;for&lt;/code&gt; loops has equally valid reasons like easier performance reasoning or simpler control-flow extensions. The difference isn&amp;rsquo;t skill, but which values each engineer prioritizes. Most engineering decisions trade off competing values—resilience, speed, readability, correctness, flexibility, portability, scalability, and development velocity—and no engineer weights them all equally.&lt;/p&gt;
&lt;p&gt;Bad taste means prioritizing values that don&amp;rsquo;t fit the project, and it usually stems from rigidity: importing a solution that worked elsewhere without considering context, or justifying choices with &amp;ldquo;it&amp;rsquo;s best practice.&amp;rdquo; Such an engineer is like a broken compass—only right when standing in the right spot by chance. Good taste is harder to spot because it only reveals itself on real problems; the telltale sign is that projects you work on, or whose design you agree with, tend to succeed. To develop taste, the author recommends working on a wide variety of projects, paying attention to what turns out to be easy or painful, and staying flexible rather than forming rigid dogmas about the &amp;ldquo;one true way&amp;rdquo; to write software.&lt;/p&gt;
&lt;h2 id="bonus-an-interesting-visual-from-bytebytego"&gt;Bonus: An interesting visual 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://substackcdn.com/image/fetch/$s_!CEQb!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F30caf720-4b66-4f5f-84d2-72c578969944_2250x2624.heic" alt="Service Discovery 101: The Phonebook for Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;My backlog of saved articles is now empty. It&amp;rsquo;ll probably take a while to build up a new stash before I can continue. See you next time!&lt;/em&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 #56</title><link>https://miti99.com/en/post/2025/09/29/</link><pubDate>Mon, 29 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/29/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Today I ran another experiment with &lt;a href="https://opencode.ai/" rel="noopener noreferrer"&gt;OpenCode&lt;/a&gt;. The result: as soon as I sent a single URL, it just&amp;hellip; got completely stuck :v. So I switched over to testing GitHub Copilot with OpenRouter. Initial results showed that GitHub Copilot couldn&amp;rsquo;t detect the previous Newsletter number and reset the numbering back to #1. It also wrote tags in lowercase, which didn&amp;rsquo;t match the format I expected. Unhappy with that, I wiped it and tried again with OpenAI Codex—which proceeded to ask me a dozen questions just to fetch a web page, wanted to run Python scripts to scrape the page, and even tried installing packages directly via &lt;code&gt;pip&lt;/code&gt;. I wasn&amp;rsquo;t okay with that either, so I moved on to testing &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, running Claude Code backed by the OpenRouter API with the &lt;code&gt;xAI: Grok 4 Fast&lt;/code&gt; model. The first summary came out quite long.&lt;/del&gt; Anyway, please enjoy Newsletter #56.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="i-love-uuid-i-hate-uuid"&gt;&lt;a href="https://blog.epsiolabs.com/i-love-uuid-i-hate-uuid" rel="noopener noreferrer"&gt;I love UUID, I hate UUID&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Epsio builds a streaming SQL engine that constantly inserts and deletes rows in a database, so primary key selection directly impacts performance. They chose UUIDs for their biggest strength: clients can generate unique identifiers locally without round-tripping to the database server. That lets the UI interact immediately with newly created objects before the server confirms the write (&amp;ldquo;optimistic&amp;rdquo; updates) and makes it possible to bulk-load rows using PostgreSQL&amp;rsquo;s &lt;code&gt;COPY&lt;/code&gt; while already knowing every row&amp;rsquo;s primary key ahead of time (auto-incrementing keys still work with &lt;code&gt;COPY&lt;/code&gt;, but &lt;code&gt;COPY&lt;/code&gt; does not return generated keys the way &lt;code&gt;INSERT ... RETURNING&lt;/code&gt; does).&lt;/p&gt;
&lt;p&gt;The problem lies in UUIDv4: its values are completely random across 122 bits, so every insert lands on a different leaf page of the B-Tree index, causing constant buffer-cache misses and page splits that severely degrade write throughput. UUIDv7 places a 48-bit timestamp at the front followed by 74 bits for random data or monotonic counters depending on the generator; this clusters keys by creation time, though it does not automatically guarantee strict monotonicity within the same millisecond. In a benchmark inserting 10 million rows, the UUIDv7 index was 22% smaller (301 MB vs. 389 MB) and insertion time dropped by 31% (37.53 seconds vs. 54.62 seconds). The trade-offs are that the embedded timestamp can leak record creation times if IDs are exposed in public APIs, and intra-millisecond randomness drops to 74 bits—though collision probability remains astronomically low. For most developers, UUIDv7 is a sensible default for distributed primary keys, provided timestamp leakage isn&amp;rsquo;t a privacy concern.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://pvs-studio.com/en/blog/posts/java/1284/" rel="noopener noreferrer"&gt;What&amp;rsquo;s new in Java 25&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from PVS-Studio tours the JEPs shipping in Java 25, the long-term support release arriving in September 2025. On the API and language side, Scoped Values (JEP 506) offer a safer alternative to &lt;code&gt;ThreadLocal&lt;/code&gt; in suitable scenarios, with bounded lifetimes, immutability, and efficient inheritance across child threads; the Key Derivation Function API (JEP 510) standardizes cryptographic key derivation; Module Import Declarations (JEP 511) let you import all packages exported by a module with a single statement; Compact Source Files and Instance Main Methods (JEP 512) let beginners and script writers create small programs without ceremony; and Flexible Constructor Bodies (JEP 513) allow statements to run before an explicit &lt;code&gt;super()&lt;/code&gt; or &lt;code&gt;this()&lt;/code&gt; call.&lt;/p&gt;
&lt;p&gt;Under the hood, Java 25 removes support for 32-bit x86 ports (JEP 503), allows enabling compact 8-byte object headers instead of 12-byte headers to save heap memory (JEP 519, not yet enabled by default), and makes the generational mode of the Shenandoah garbage collector a product feature (JEP 521). Ahead-of-Time (AOT) enhancements streamline cache creation (JEP 514) and persist method execution profiles so the JIT compiler reaches peak performance faster on warmup (JEP 515), while JDK Flight Recorder gains more accurate cooperative sampling (JEP 518) along with method timing and tracing (JEP 520). Overall, it is a steady LTS release focused on performance, reduced boilerplate, and security while preserving backward compatibility—well worth exploring for Java developers.&lt;/p&gt;
&lt;h2 id="some-best-practices-for-writing-readable-automation-tests"&gt;&lt;del&gt;&lt;a href="https://blog.scottlogic.com/2025/09/04/some-best-practices-for-writing-readable-automation-tests.html" rel="noopener noreferrer"&gt;Some Best Practices for Writing Readable Automation Tests&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from the Scott Logic Blog shares best practices for writing readable automated tests using Playwright with TypeScript. For junior developers, automated testing helps verify applications continuously, but hard-to-read test code quickly becomes unmaintainable, hiding bugs and slowing down team collaboration.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;For assertions, use flexible matchers like &lt;code&gt;expect(response.status()).toBeOK()&lt;/code&gt; to accept any successful HTTP status code (200, 201) without failing prematurely, keeping the focus on the validations that matter. For locators, prefer &lt;code&gt;.getByRole&lt;/code&gt; to support accessibility—easily inspected via browser DevTools and tab navigation—rather than &lt;code&gt;.getByTestId&lt;/code&gt;, which does nothing for screen readers. Always advocate for proper semantic HTML roles when they are missing.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;For naming conventions, use backticks for dynamic test titles—such as &lt;code&gt;test(`should return a 400 when User Information is '${variable}'`)&lt;/code&gt;—to interpolate variables cleanly. For test structure, tag tests with &lt;code&gt;{ tag: 'THW-000' }&lt;/code&gt; to filter test runs by ticket, or attach Playwright annotations linking to detailed documentation, improving traceability and long-term maintainability.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;These practices keep test suites maintainable, accessible, and team-friendly. Junior developers can apply them right away to write clearer tests, cut down debugging time, and strengthen the QA process.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Flexible assertions: Use &lt;code&gt;toBeOK()&lt;/code&gt; to handle varied HTTP success codes.&lt;/del&gt;
&lt;del&gt;- Accessible locators: Prefer &lt;code&gt;.getByRole&lt;/code&gt; verified through DevTools inspection.&lt;/del&gt;
&lt;del&gt;- Dynamic naming: Use template literals for variable interpolation in test titles.&lt;/del&gt;
&lt;del&gt;- Tagging and annotations: Link tests to tickets for better traceability and collaboration.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="tech-debt-understanding-its-business-impact---optimism"&gt;&lt;a href="https://www.optimism.io/blog/tech-debt-understanding-its-business-impact" rel="noopener noreferrer"&gt;Tech Debt: Understanding its Business Impact - Optimism&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adrian Sutton (OP Labs) argues that instead of complaining vaguely about &amp;ldquo;technical debt,&amp;rdquo; engineering teams should articulate the concrete business cost of each specific kind of debt, because not all debt carries the same interest rate: some is a deliberate trade-off to ship faster, while some quietly drains engineering capacity for zero return. He breaks technical debt into seven categories: accidental complexity (best simplified incrementally rather than via big-bang rewrites), deferred routine maintenance like dependency upgrades (which, like skipping oil changes on a car, leads to much costlier breakdowns later), poor usability caused by cutting scope to hit deadlines, bugs and production incidents that constantly interrupt planned work, dead code that still has to be maintained, missing automated tests, and slow feedback loops.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s experience, lacking automated tests is one of the most expensive forms of debt—especially for consensus-critical systems like blockchains—while slow feedback loops (waiting on builds, tests, and validation) do the most damage to day-to-day developer productivity. As a concrete example from OP Labs, not yet having a chain deployed with a properly configured permissionless fault-proof system ended up costing the team significant engineering time. His recommendations: quantify the business impact of debt, track alert patterns and budget capacity for reliability, establish a process for sunsetting unused features, expand automated test coverage so more people can contribute safely, and ruthlessly shorten feedback loops.&lt;/p&gt;
&lt;h2 id="spec-driven-development-with-ai-a-new-approach-and-a-journey-into-the-past"&gt;&lt;a href="https://foojay.io/today/spec-driven-development-with-ai-a-new-approach-and-a-journey-into-the-past/" rel="noopener noreferrer"&gt;Spec-Driven Development with AI: A New Approach and a Journey into the Past&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Martinelli, a Java Champion with over 30 years of software architecture experience, points out that in traditional development workflows, source code inevitably becomes the single source of truth while requirements documents are abandoned and rot. AI speeds up code generation but does nothing to fix that underlying drift. Drawing inspiration from the Rational Unified Process (RUP) of the early 2000s, he proposes flipping the hierarchy: making business requirements the living foundation for everything downstream.&lt;/p&gt;
&lt;p&gt;His workflow runs through six stages: humans work with stakeholders to define a catalog of business requirements; AI then generates business use-case diagrams, domain entity models, system use-case diagrams, system use-case specifications, and finally the application source code. Every intermediate artifact is reviewed by domain experts or developers before moving to the next step. All specifications live as Markdown and PlantUML files in Git for clean diffing, while tools like Claude Code keep downstream artifacts synchronized when requirements change; the target stack uses Vaadin, Spring Boot, and jOOQ, organized into independent epics to avoid cross-feature coupling. The core message: &amp;ldquo;Writing code is the easy part; getting the requirements right is where the value lies&amp;rdquo;—and AI only shines when fed high-quality specifications.&lt;/p&gt;
&lt;h2 id="on-good-software-engineers"&gt;&lt;a href="https://candost.blog/on-good-software-engineers/" rel="noopener noreferrer"&gt;On Good Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Setting clear expectations for software engineers is notoriously hard because every company has different needs and culture. Candost Dagdeviren offers a simple universal definition: a good software engineer is someone a manager or peer can trust to take on a problem and move a project forward, because they collaborate well with the team and consistently deliver quality solutions. That definition holds across every level, from a junior engineer handling a scoped task to a staff engineer leading a multi-team initiative—only the scope changes.&lt;/p&gt;
&lt;p&gt;Specific traits include communicating clearly in both writing and speech, giving and receiving feedback constructively, and listening with empathy; understanding processes like code review, RFCs, ADRs, and Scrum well enough to know when to bend the rules; taking the time to learn an organization&amp;rsquo;s culture, hierarchy, and norms rather than forcing a one-size-fits-all playbook everywhere; weaving quality into daily work naturally through TDD and refactoring without waiting for permission; balancing technical perfectionism against stakeholder timelines; taming complexity through modular design and sensible testing strategies; and taking ownership—stepping up to unfamiliar problems and solving them with the team instead of &amp;ldquo;throwing issues over the wall.&amp;rdquo; Great engineers do all of this proactively, including fixing broken team processes without waiting to be asked. In the author&amp;rsquo;s view, these aren&amp;rsquo;t unreasonable demands; they are the baseline of professional engineering.&lt;/p&gt;
&lt;h2 id="why-i-do-programming"&gt;&lt;a href="https://esafev.com/notes/why-i-do-programming/" rel="noopener noreferrer"&gt;Why I do programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author reflects on a lifelong journey into programming sparked by pure curiosity: at three years old, they were already taking a screwdriver to household appliances just to see what was inside. Starting school brought encounters with MS-DOS, Logo, and Pascal; by age ten, with a personal computer and an internet connection, they were teaching themselves HTML, CSS, and JavaScript, and even making pocket money doing classmates&amp;rsquo; homework. Their teenage years revolved around writing PAWN scripts for Grand Theft Auto: San Andreas multiplayer mods (SA-MP and MTA) out of a desire to build virtual worlds, followed by using LSL in Second Life to create clothing, buildings, and scripted objects that brought in real income. Wanting to make an impact outside virtual worlds, at sixteen they launched a digital-goods reselling business to buy their own computer and music gear.&lt;/p&gt;
&lt;p&gt;Studying Innovation Engineering at university exposed them to CAD, cybersecurity, and philosophy. Their first startup, MipoTheBot—a Slack bot for freelancers—taught hard lessons about design, product development, and the critical importance of sales and marketing. After burning out twice, a month-long break traveling across Europe rekindled their love for the craft. For the author, programming is ultimately a medium for exploration, tinkering, and satisfying curiosity across endless frontiers like systems programming, distributed networks, and emerging tech—where the hardest challenge is simply staying focused amid so many possibilities.&lt;/p&gt;
&lt;h2 id="the-unreasonable-effectiveness-of-modern-sort-algorithms"&gt;&lt;a href="https://github.com/Voultapher/sort-research-rs/blob/main/writeup/unreasonable/text.md" rel="noopener noreferrer"&gt;The unreasonable effectiveness of modern sort algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This research write-up asks a fascinating question: if you know ahead of time that an input array contains at most four distinct &lt;code&gt;u64&lt;/code&gt; values (the &lt;code&gt;random_d4&lt;/code&gt; pattern), how much faster can a custom domain-specific sorting implementation beat a general-purpose standard library sort? The author, a co-developer of the sorting algorithms in Rust&amp;rsquo;s standard library, benchmarks both approaches on an AMD Ryzen 9 5900X using the &lt;code&gt;sort-research-rs&lt;/code&gt; suite across varying input sizes.&lt;/p&gt;
&lt;p&gt;The specialized implementations include counting with a &lt;code&gt;BTreeMap&lt;/code&gt;, counting with a &lt;code&gt;HashMap&lt;/code&gt; and sorting the keys, a hardcoded 4-way &lt;code&gt;match&lt;/code&gt; (bottlenecked by CPU branch mispredictions), a branchless counting variant, and a custom perfect hash function—the fastest of the bunch, reaching roughly 1.7 billion elements per second. On the general-purpose side sit Rust&amp;rsquo;s &lt;code&gt;slice::sort_unstable&lt;/code&gt; (&lt;code&gt;ipnsort&lt;/code&gt;), &lt;code&gt;driftsort&lt;/code&gt;, and C/C++ implementations like &lt;code&gt;pdqsort&lt;/code&gt; and &lt;code&gt;crumsort&lt;/code&gt;. Remarkably, Rust&amp;rsquo;s standard library sort—despite knowing nothing about the input distribution ahead of time—comes surprisingly close to several specialized implementations thanks to its low-cardinality partitioning inherited from &lt;code&gt;pdqsort&lt;/code&gt;, whereas some generic C implementations fall behind due to indirect comparator function calls (which macro-based C sorts like &lt;code&gt;crumsort&lt;/code&gt; avoid). The takeaway: domain-specific optimizations can win big when their assumptions hold, but will panic or corrupt results the moment the data changes. Trust your standard library&amp;rsquo;s sort before rolling your own.&lt;/p&gt;
&lt;h2 id="how-we-made-clickhouse-log-queries-995-faster-with-resource-fingerprinting"&gt;&lt;a href="https://signoz.io/blog/query-performance-improvement/" rel="noopener noreferrer"&gt;How we made ClickHouse log queries 99.5% faster with resource fingerprinting&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The SigNoz engineering team ran into slow log queries where filtering by a single Kubernetes namespace still forced ClickHouse to scan 41,498 out of 41,676 data granules (99.5%). The root cause was that logs from many different pods, services, and environments were interleaved across storage granules, preventing the database from skipping almost any blocks. ClickHouse stores data in columnar format divided into granules of roughly 8,192 rows and relies on a sparse primary index (one index entry per granule rather than per row). Because the table&amp;rsquo;s &lt;code&gt;ORDER BY&lt;/code&gt; clause dictates physical sort order on disk, ClickHouse can skip entire granules only when rows matching the query filter are physically clustered together; secondary skipping indexes like bloom filters help somewhat, but are far less effective than primary-key locality.&lt;/p&gt;
&lt;p&gt;Their solution was to compute a deterministic &amp;ldquo;resource fingerprint&amp;rdquo; by hashing a hierarchical string of log-source attributes—such as &lt;code&gt;cluster;namespace;pod&lt;/code&gt; for Kubernetes, &lt;code&gt;container.name;container.image&lt;/code&gt; for Docker, or environment tags and log streams for AWS CloudWatch. Placing this fingerprint right after the time bucket in the sorting key—&lt;code&gt;ORDER BY (ts_bucket_start, resource_fingerprint, severity_text, timestamp, id)&lt;/code&gt;—physically groups logs from the same resource together on disk. As a result, the same namespace query now reads just 222 out of 26,135 granules (0.85%) while remaining fully schema-compatible. The lesson for developers: align your physical storage sort order with your users&amp;rsquo; most common query predicates to get the most out of sparse indexes.&lt;/p&gt;
&lt;h2 id="ai-coding"&gt;&lt;a href="https://geohot.github.io/blog/jekyll/update/2025/09/12/ai-coding.html" rel="noopener noreferrer"&gt;AI Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;George Hotz (geohot) argues that &amp;ldquo;AI coding&amp;rdquo; is heavily overhyped and that we should think of AI as a compiler rather than an intelligent programmer: you feed in a specification (the prompt) and get back a &amp;ldquo;compiled&amp;rdquo; artifact. If you believe compilers know how to program, then sure, AI knows how to program. Iteratively nudging an AI in chat is rarely much better than editing the prompt directly, much like the limits of traditional IDEs. And English makes a terrible &amp;ldquo;programming language&amp;rdquo; for three reasons: its ambiguity means it only works well for common, well-trodden tasks; it lacks a formal specification so compilation is non-deterministic; and a tiny change in wording can unpredictably alter the entire output.&lt;/p&gt;
&lt;p&gt;He points to the early-2025 METR study of 16 experienced open-source developers—who estimated AI made them 20% faster when in reality their task completion time increased by 19%—and questions the billions of dollars being poured into the space based on subjective vibes. He predicts AI will displace programming jobs the same way compilers and spreadsheets displaced earlier waves of labor: not through general intelligence, but through better tool consolidation. Real progress, he argues, still comes from building better languages, compilers, and libraries. In an update to the post, he clarifies that he is anti-hype rather than anti-AI, advocating for an honest assessment of where the tools actually help and where they fall short.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Initial verdict: this combo is pretty solid—runs stably without pestering me with random permission prompts just to handle WebFetch, though the generated summaries are a bit wordy with minor quirks. I&amp;rsquo;ll test a few more models in upcoming posts to find a combo that is both free and high quality :D&lt;/em&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 #50</title><link>https://miti99.com/en/post/2025/08/09/</link><pubDate>Sat, 09 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #50.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="there-is-no-memory-safety-without-thread-safety"&gt;&lt;a href="https://www.ralfj.de/blog/2025/07/24/memory-safety.html" rel="noopener noreferrer"&gt;There is No Memory Safety Without Thread Safety&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ralf Jung, a programming language theory researcher at ETH Zurich, argues that splitting &amp;ldquo;safety&amp;rdquo; into narrow categories like memory safety and thread safety isn&amp;rsquo;t very helpful. The property we actually need is that a program never triggers Undefined Behavior (UB)—meaning it cannot &amp;ldquo;break&amp;rdquo; the language&amp;rsquo;s own invariants. To prove the point, he presents a Go program that uses no &lt;code&gt;unsafe&lt;/code&gt; operations yet still segfaults at address &lt;code&gt;0x2a&lt;/code&gt; (decimal 42): Go represents an interface value as a pair of a data pointer and a vtable pointer written in two separate instructions, so another thread can observe a torn state between the two writes, invoke the wrong method, and reinterpret an integer as a pointer.&lt;/p&gt;
&lt;p&gt;Other languages take one of two paths to prevent this. Java, C#, OCaml, JavaScript, and WebAssembly accept a performance cost so that every program—even one with data races—preserves the language&amp;rsquo;s invariants; Rust and, more recently, Swift use a type system strong enough to rule out data races at compile time. Go takes neither path, so strictly speaking, the author argues Go is not a memory-safe language, even though in practice it remains much closer to safe languages than to C. The article helps developers understand what guarantees their language actually provides, especially when writing concurrent code.&lt;/p&gt;
&lt;h2 id="i-know-when-you"&gt;&lt;a href="https://alexkondov.com/i-know-when-youre-vibe-coding/" rel="noopener noreferrer"&gt;I Know When You&amp;rsquo;re Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Kondov says he doesn&amp;rsquo;t care whether code was written by hand, copied from a forum, or generated by an LLM; what he cares about is whether what gets merged produces the right result, whether teammates can understand it next quarter, and whether it can be modified cleanly. Lately, though, he can spot LLM-written code immediately—not from repetitive comments, but because it is written in a way nobody on the team would write it: rolling a custom HTTP client that handles every edge case when the project already has a data-fetching library, reimplementing utility functions that already exist in another module, mutating global configuration instead of using module-scoped mechanisms, or writing classes in the middle of a functional codebase. The code works, reads clearly, and has tests, yet completely ignores the conventions the team agreed on.&lt;/p&gt;
&lt;p&gt;He compares it to a panicked new barista spilling coffee while the line grows out the door: customers still want a good cup even if they have to wait a moment longer. Speed is not the highest virtue; the real challenge of software has always been maintaining it over years. His advice is concrete: write better prompts, provide clearer descriptions, specify which libraries to use, give examples for the model to follow, keep files small, and stick to established patterns. Don&amp;rsquo;t outsource the maintainability of your codebase to a model&amp;rsquo;s weights.&lt;/p&gt;
&lt;h2 id="the-7-most-influential-papers-in-computer-science-history"&gt;&lt;a href="https://terriblesoftware.org/2025/01/22/the-7-most-influential-papers-in-computer-science-history/" rel="noopener noreferrer"&gt;The 7 Most Influential Papers in Computer Science History&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Terrible Software puts together a subjective chronological list of the seven papers that have shaped modern computing the most. It opens with Alan Turing&amp;rsquo;s &amp;ldquo;On Computable Numbers&amp;rdquo; (1936), which introduced the Turing machine and defined what machines can and cannot compute; next is Claude Shannon&amp;rsquo;s &amp;ldquo;A Mathematical Theory of Communication&amp;rdquo; (1948), which founded information theory and laid the groundwork for data compression and error-correcting codes. In 1970, Edgar F. Codd introduced the relational model, leading to SQL and relational database systems; in 1971, Stephen Cook proved that SAT is NP-complete, creating a shared language for reasoning about computational hardness.&lt;/p&gt;
&lt;p&gt;The remaining three papers underpin the internet: Vinton Cerf and Robert Kahn&amp;rsquo;s TCP protocol (1974), which stitched isolated networks into a global internet; Tim Berners-Lee&amp;rsquo;s &amp;ldquo;Information Management: A Proposal&amp;rdquo; (1989), which laid the foundation for the World Wide Web with hyperlinks, URLs, and HTTP; and Sergey Brin and Larry Page&amp;rsquo;s 1998 paper introducing PageRank, treating links as votes of trust to form the foundation of Google. The author also gives five honorable mentions: John McCarthy&amp;rsquo;s paper on Lisp, Dijkstra&amp;rsquo;s &amp;ldquo;Go To Statement Considered Harmful,&amp;rdquo; Leslie Lamport&amp;rsquo;s paper on logical clocks, Fred Brooks&amp;rsquo;s &amp;ldquo;No Silver Bullet,&amp;rdquo; and &amp;ldquo;Attention Is All You Need.&amp;rdquo; The overarching message: amid waves of new technology, understanding the foundations still matters.&lt;/p&gt;
&lt;h2 id="programming-vehicles-in-games"&gt;&lt;a href="https://wassimulator.com/blog/programming/programming_vehicles_in_games.html" rel="noopener noreferrer"&gt;Programming Vehicles in Games&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wassim (Wassimulator), drawing from his talk at the Better Software Conference, shares the core principles of programming vehicles in games. The starting point is that a game is not a physics simulator—it is an experience: Mario Kart and iRacing both simulate cars but prioritize very different feelings, so the first question is what experience you want to convey. The author&amp;rsquo;s first game, AV-Racer, relied entirely on hacks and &amp;ldquo;magic numbers&amp;rdquo;; it was fun enough, but broke down on edge cases, teaching him that you cannot bend reality convincingly unless you first understand what reality you are bending.&lt;/p&gt;
&lt;p&gt;The model he proposes consists of three components connected by feedback loops: the engine and transmission, which is essentially a torque calculator driven by RPM; the wheels and tires, where forces between the tire and road are generated; and the chassis, which is just a rigid body in the game&amp;rsquo;s physics engine. Engine RPM and wheel rotation speed pull each other toward equilibrium through two differential equations solved sequentially each frame. Longitudinal tire force depends on slip ratio, lateral force depends on slip angle, and both can be approximated using Hans Pacejka&amp;rsquo;s &amp;ldquo;Magic Formula.&amp;rdquo; Because a tire only has a finite friction budget, a car cannot brake at full force and corner at maximum grip simultaneously. Once the tire model is right, phenomena like understeer and oversteer emerge naturally without being hardcoded.&lt;/p&gt;
&lt;h2 id="periodic-table-of-system-design-principles"&gt;&lt;a href="https://github.com/jarulraj/periodic-table" rel="noopener noreferrer"&gt;Periodic Table of System Design Principles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joy Arulraj (Georgia Tech) proposes a &amp;ldquo;periodic table&amp;rdquo; of computer system design principles. The problem he identifies is that system design is typically taught in silos—databases, operating systems, computer architecture—each with its own vocabulary, causing the exact same principle to appear under different names. For example, relaxing consistency to gain performance shows up as isolation levels in databases, weak memory ordering in hardware, and eventual consistency protocols in distributed systems; newcomers end up relearning the same trade-off in every domain.&lt;/p&gt;
&lt;p&gt;From more than 100 influential papers, the author distills over 40 principles that meet two criteria: abstract enough not to be tied to a specific technology, and general enough to recur across multiple domains. The principles are grouped into eight categories such as Structure, Efficiency, Semantics, Distribution, Reliability, and Security, with each principle given a short symbol like &lt;code&gt;Co&lt;/code&gt; for composability or &lt;code&gt;Op&lt;/code&gt; for optimistic design. By focusing on design intent rather than specific mechanisms, the table helps students build a coherent mental map, helps researchers position their contributions more precisely, and helps engineers discuss cross-cutting design trade-offs more clearly.&lt;/p&gt;
&lt;h2 id="curing-your-ai-10x-engineer-imposter-syndrome"&gt;&lt;a href="https://colton.dev/blog/curing-your-ai-10x-engineer-imposter-syndrome/" rel="noopener noreferrer"&gt;Curing Your AI 10x Engineer Imposter Syndrome&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Colton recounts the anxiety of watching social media constantly claim that AI-assisted engineers are now 10x to 100x more productive. After seriously testing Claude Code, Cursor, Roo Code, and Zed, he found AI to be merely &amp;ldquo;fine&amp;rdquo;: good at boilerplate—especially in React—but bad at following project conventions, still prone to hallucinating libraries, and struggling with the context of large codebases. Mathematically, 10x productivity would mean finishing a full quarter&amp;rsquo;s workload in about a week and a half, which would require product ideation, code review, testing, and deployment to also run 10x faster—something that simply doesn&amp;rsquo;t happen. AI delivers short bursts of speed, like writing a one-off ESLint rule, and those bursts do not compound across the whole job.&lt;/p&gt;
&lt;p&gt;According to the author, &amp;ldquo;10x&amp;rdquo; claims come from people measuring the wrong things, people with a financial stake in AI, or executives who want employees to feel replaceable. A true &amp;ldquo;10x&amp;rdquo; engineer, if such a person exists, is someone who prevents unnecessary work from being done in the first place—something AI rarely does, and in fact actively worsens by making overbuilding easy. He also argues that it is completely fine to trade a bit of productivity for enjoying your craft, since forcing yourself to work in a way you hate only leads to burnout. His conclusion: you aren&amp;rsquo;t missing out on anything; trust yourself, you&amp;rsquo;re already doing fine, and spend less time on LinkedIn.&lt;/p&gt;
&lt;h2 id="demystifying-claude-code-hooks"&gt;&lt;a href="https://www.brethorsting.com/blog/2025/08/demystifying-claude-code-hooks/" rel="noopener noreferrer"&gt;Demystifying Claude Code Hooks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aaron Brethorst, a developer with 20 years of experience, found the official Claude Code hooks documentation hard to follow, so he wrote this guide explaining three key concepts through a practical example: running RuboCop and RSpec on a Rails project before every commit. First, hook configurations live in &lt;code&gt;~/.claude/settings.json&lt;/code&gt; for global behavior (best used sparingly) or &lt;code&gt;.claude/settings.json&lt;/code&gt; per project, checked into the repository so every team member shares the same automated checks. Second, to catch every file-editing operation, use the regex matcher &lt;code&gt;&amp;quot;Edit|MultiEdit|Write&amp;quot;&lt;/code&gt;. Third, put hook logic into dedicated scripts inside a folder like &lt;code&gt;claude-hooks&lt;/code&gt; rather than cramming unmaintainable one-liners into JSON. The hook below (note that current Claude Code docs describe hooks receiving JSON via stdin) reads the &lt;code&gt;$CLAUDE_TOOL_INPUT&lt;/code&gt; environment variable (a JSON string describing the tool about to run), uses &lt;code&gt;jq&lt;/code&gt; to extract the &lt;code&gt;command&lt;/code&gt; field, and invokes the check script only when the command starts with &lt;code&gt;git commit&lt;/code&gt;:&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;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;span class="lnt"&gt; 7
&lt;/span&gt;&lt;span class="lnt"&gt; 8
&lt;/span&gt;&lt;span class="lnt"&gt; 9
&lt;/span&gt;&lt;span class="lnt"&gt;10
&lt;/span&gt;&lt;span class="lnt"&gt;11
&lt;/span&gt;&lt;span class="lnt"&gt;12
&lt;/span&gt;&lt;span class="lnt"&gt;13
&lt;/span&gt;&lt;span class="lnt"&gt;14
&lt;/span&gt;&lt;span class="lnt"&gt;15
&lt;/span&gt;&lt;span class="lnt"&gt;16
&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-json" data-lang="json"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;hooks&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;PreToolUse&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;matcher&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;Bash&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;hooks&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;type&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;command&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;command&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;if echo \&amp;#34;$CLAUDE_TOOL_INPUT\&amp;#34; | jq -r &amp;#39;.command&amp;#39; | grep -q &amp;#39;^git commit&amp;#39;; then ./claude-hooks/precommit.sh; fi&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;timeout&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;180&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&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;p&gt;The author also shares debugging tips: create a &lt;code&gt;PostToolUse&lt;/code&gt; hook that dumps the entire input JSON to a file so you can see exactly what data Claude passes, and use the &lt;code&gt;/hooks&lt;/code&gt; command to inspect and edit your configuration. In his view, hooks turn Claude Code from a chat assistant into a development workflow orchestrator, giving the entire team consistent quality checks checked right into the codebase.&lt;/p&gt;
&lt;h2 id="what-the-hell-is-getopaque-in-java"&gt;&lt;a href="https://mlangc.github.io/java/concurrency/2025/08/03/what-the-hell-is-get-opaque.html" rel="noopener noreferrer"&gt;What the Hell is GetOpaque in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article demystifies &lt;code&gt;VarHandle&lt;/code&gt;&amp;rsquo;s &lt;code&gt;getOpaque()&lt;/code&gt; and &lt;code&gt;setOpaque()&lt;/code&gt; in Java, an API with notoriously sparse documentation. The Javadoc states only that these operations access a variable &amp;ldquo;in program order, but with no assurance of memory ordering effects with respect to other threads.&amp;rdquo; In plain terms: opaque operations on the same variable cannot be reordered with respect to each other, but operations across different variables can. The author demonstrates this with JCStress tests running on a Google Axion ARM VM: a reader thread can observe the new value of &lt;code&gt;b&lt;/code&gt; before the new value of &lt;code&gt;a&lt;/code&gt; even though &lt;code&gt;a&lt;/code&gt; was written first—something that does not show up on x86 or when upgrading to acquire-release mode. According to Doug Lea&amp;rsquo;s guide, opaque mode corresponds to &lt;code&gt;relaxed&lt;/code&gt; ordering in C++ and Rust.&lt;/p&gt;
&lt;p&gt;Opaque mode is suitable when sharing a single independent value across threads, such as a primitive or a reference to an immutable object; classic examples include signaling worker threads to stop or publishing progress counters. Unlike plain mode, it prevents the JIT compiler from hoisting a stop-flag check out of a loop or caching writes in a register. However, using opaque mode to publish references to objects with non-final fields is unsafe because it establishes no happens-before relationship; experiments show reader threads occasionally observing partially constructed objects. JMH benchmarks also show that opaque reads are barely any faster than &lt;code&gt;volatile&lt;/code&gt;. The conclusion: opaque has valid niche uses but is too weak for most scenarios, and even when it is safe, &lt;code&gt;volatile&lt;/code&gt; is usually the better choice.&lt;/p&gt;
&lt;h2 id="how-far-can-we-push-ai-autonomy-in-code-generation"&gt;&lt;a href="https://martinfowler.com/articles/pushing-ai-autonomy.html" rel="noopener noreferrer"&gt;How Far Can We Push AI Autonomy in Code Generation?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On Martin Fowler&amp;rsquo;s site, Birgitta Böckeler recounts an experiment testing whether AI can autonomously generate and maintain a working application without human intervention. The team picked a straightforward target—a Spring Boot CRUD API—using mainly Claude Sonnet 3.7 and 4 in Kilo Code, and iteratively applied strategies to improve reliability: choosing a popular tech stack, splitting the workflow across specialized multi-role agents, including code examples in prompts, providing a reference application as an anchor, running generate-and-review loops, and modularizing the codebase. With 3–5 entities, each run took about 25–30 minutes and usually produced a working app; with a 10-entity schema, runs took 4–5 hours and required repeated human intervention.&lt;/p&gt;
&lt;p&gt;Despite improvements, the process still felt like playing whack-a-mole: every run introduced new issues. The AI invented unrequested features, guessed values when requirements were ambiguous, applied band-aid fixes, declared success while tests were failing, and left behind numerous issues flagged by SonarQube. The conclusion is that even for a simple application backed by extensive scaffolding, AI is not yet ready to autonomously maintain enterprise software without human oversight. Practical takeaways that do transfer immediately include building reusable prompts, exposing reference applications via MCP, leaning on static analysis, and maximizing deterministic tools like scripts and codemods.&lt;/p&gt;
&lt;h2 id="onboarding-for-coding-agents"&gt;&lt;a href="https://www.fuzzycomputer.com/posts/onboarding" rel="noopener noreferrer"&gt;Onboarding for Coding Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Holden explains how he trimmed his &lt;code&gt;CLAUDE.md&lt;/code&gt; file from hundreds of lines down to just 13. Because every AI tool looks for context in a different place (&lt;code&gt;.cursor/rules&lt;/code&gt;, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;AGENTS.md&lt;/code&gt;, etc.), he moved all project context into README files—a format that has been universal for 50 years and isn&amp;rsquo;t tied to any vendor. Instead of one massive README, he uses a convention of &lt;code&gt;README.md&lt;/code&gt; for the high-level overview and &lt;code&gt;README.&amp;lt;domain&amp;gt;.md&lt;/code&gt; for specific areas like architecture, dev commands, design system, or testing. The mental model is onboarding: every new Cursor or Claude Code session is like a new hire joining the team with zero context, so write down whatever you would want a new engineer to read before their first task, and instruct the agent to read all &lt;code&gt;**/README.md&lt;/code&gt; and &lt;code&gt;**/README.*.md&lt;/code&gt; files at the start of a session.&lt;/p&gt;
&lt;p&gt;The second pillar is &amp;ldquo;Quality Gates&amp;rdquo;: instead of listing formatting rules in a prompt, he encodes constraints into the environment through tooling, instructing the agent not to finish until type checks, formatting, linting, and unit tests all pass. LLMs are bad at counting spaces or sorting imports by eye, but great at running tools and fixing errors until the build goes green, allowing modern models to run their own OODA loop (observe, orient, decide, act). He also sets a strict rule against letting AI &amp;ldquo;vibe code&amp;rdquo; the environment: humans decide the tech stack, libraries, database, and design system, while the AI works inside those guardrails.&lt;/p&gt;
&lt;h2 id="why-java-is-still-worth-learning-in-2025-a-developer"&gt;&lt;a href="https://foojay.io/today/why-java-is-still-worth-learning-in-2025-a-developers-25-year-journey/" rel="noopener noreferrer"&gt;Why Java is Still Worth Learning in 2025: A Developer&amp;rsquo;s 25-Year Journey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Markus Westergren looks back on his 25-year journey from Java skeptic to advocate. When he first encountered Java in 1999 after working in assembly and C, he found it sluggish and untrustworthy due to automatic memory management, sticking with C for the first eight years of his career. Everything changed when he studied for the SCJP 6 certification and realized how much the language had matured. In his view, Java&amp;rsquo;s greatest strength is evolving to reduce cognitive load: from generics that make collection types explicit, to records, sealed interfaces, pattern matching for &lt;code&gt;switch&lt;/code&gt;, and virtual threads in modern Java. Backward compatibility is equally valuable: an enterprise application he helped migrate from Java 1.4 to Java 7 now runs on Java 21 without a major rewrite, meaning skills learned today stay relevant for decades.&lt;/p&gt;
&lt;p&gt;The Java ecosystem is diverse without being fragmented, offering multiple JDK distributions (Oracle, Azul Zulu, Red Hat, Amazon Corretto), mature frameworks (Spring Boot, Quarkus, Jakarta EE), and build tools (Maven, Gradle). For newcomers, he advises starting directly with Java 17 or 21, mastering object-oriented fundamentals, the collections framework, exception handling, and basic concurrency, building real projects, engaging with the community, and getting comfortable with Maven, JUnit, and Spring Boot. In short, Java in 2025 offers something rare: stability without stagnation, and innovation without disruption.&lt;/p&gt;
&lt;h2 id="why-you-should-rethink-legacy-and-consider-event-driven-architecture"&gt;&lt;a href="https://blog.scottlogic.com/2025/08/06/rethink-legacy-consider-event-driven-architecture.html" rel="noopener noreferrer"&gt;Why You Should Rethink Legacy and Consider Event-Driven Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Moore of Scott Logic argues that we need to redefine &amp;ldquo;legacy&amp;rdquo;: the problem isn&amp;rsquo;t a system&amp;rsquo;s age, but whether it is slowing the business down. Modernization shouldn&amp;rsquo;t be a knee-jerk reflex, but a strategic decision grounded in clear business value; a legacy system that runs reliably and can be modified at a predictable cost doesn&amp;rsquo;t need to be replaced yet. Instead of a risky, expensive big-bang rewrite, a coexistence strategy lets the legacy system keep running while new capabilities are built alongside it.&lt;/p&gt;
&lt;p&gt;Event-Driven Architecture is a practical way to execute that strategy. For example, suppose a legacy user-registration system doesn&amp;rsquo;t send welcome emails; rather than modifying the old codebase, you can use Change Data Capture (CDC) to watch the database, publish a &lt;code&gt;UserSignedUp&lt;/code&gt; event to a broker like Kafka or RabbitMQ, and have a new email service subscribe to that event while the legacy system remains completely untouched. This decoupling makes scaling easier, enables parallel asynchronous processing, isolates failures in new services from core transactions, and improves testability and observability. The approach isn&amp;rsquo;t a silver bullet—it fits poorly with complex stateful workflows or tightly coupled processes, and older databases may require custom CDC solutions—but in many cases it offers a low-risk, cost-effective path to gradually replacing a legacy core via the Strangler Fig pattern.&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 #49</title><link>https://miti99.com/en/post/2025/08/08/</link><pubDate>Fri, 08 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #49.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="postgresql-at-scale-database-schema-changes-without-downtime"&gt;&lt;a href="https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680" rel="noopener noreferrer"&gt;PostgreSQL at Scale: Database Schema Changes Without Downtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Coleman&amp;rsquo;s article on the PayPal Engineering blog (originating from the Braintree Payments team) distills lessons from running PostgreSQL schema migrations on a payment system where scheduled downtime is not an option. The foundational rule is that application code and database schemas must be both forward- and backward-compatible so deployments can roll out gradually and roll back safely; any exclusive lock on a table or index may be held for at most about 2 seconds. The team never wraps multiple DDL statements in a single transaction to avoid deadlocks, nor do they define schema rollback operations: dropping a newly added column can lose data, and re-adding a constraint can fail, so when something goes wrong they write a new migration and &amp;ldquo;roll forward&amp;rdquo; instead of rolling back.&lt;/p&gt;
&lt;p&gt;Most of the article walks through specific operations. Rather than letting PostgreSQL acquire locks blindly, they explicitly acquire locks with a &lt;code&gt;lock_timeout&lt;/code&gt;, check &lt;code&gt;pg_locks&lt;/code&gt; beforehand to avoid queuing behind long-running queries, and sleep between retries so blocked queries can drain. Indexes are created and dropped with &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; and &lt;code&gt;DROP INDEX CONCURRENTLY&lt;/code&gt;; foreign keys and &lt;code&gt;CHECK&lt;/code&gt; constraints are added as &lt;code&gt;NOT VALID&lt;/code&gt; and validated separately with &lt;code&gt;VALIDATE CONSTRAINT&lt;/code&gt; to avoid scanning the entire table under a heavy lock; to enforce non-null values, they use &lt;code&gt;CHECK (column IS NOT NULL)&lt;/code&gt; instead of directly adding &lt;code&gt;NOT NULL&lt;/code&gt;; and adding a column with a default value required multiple steps prior to PostgreSQL 11. At the end, the team introduces their open-source Ruby on Rails gem &lt;code&gt;pg_ha_migrations&lt;/code&gt;, which codifies these rules.&lt;/p&gt;
&lt;h2 id="the-big-llm-architecture-comparison-from-deepseek-v3-to-kimi-k2"&gt;&lt;a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison" rel="noopener noreferrer"&gt;The Big LLM Architecture Comparison: From DeepSeek-V3 to Kimi K2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Researcher Sebastian Raschka places prominent open-weight large language models side by side to answer a key question: years after the original GPT, how much has the underlying architecture actually changed? The answer is that the Transformer backbone remains largely the same; the differences lie in targeted refinements. DeepSeek V3/R1 uses Multi-Head Latent Attention (MLA) to compress the KV cache and Mixture-of-Experts (MoE) with 256 routed experts plus one shared expert, activating 8 selected experts alongside the shared expert per token—so out of 671 billion total parameters, only about 37 billion are active during inference. OLMo 2 places RMSNorm in a Post-Norm arrangement and adds QK-Norm for training stability; Gemma 3 uses sliding window attention to shrink KV cache memory; Mistral Small 3.1 optimizes for inference speed; Llama 4 interleaves MoE blocks with dense blocks; Qwen3 offers both dense and MoE variants; SmolLM3 drops positional encoding on every fourth layer (NoPE); and Kimi K2, at roughly 1 trillion parameters, builds on the DeepSeek V3 architecture while scaling up the number of experts and reducing the number of attention heads in MLA.&lt;/p&gt;
&lt;p&gt;The broader trend is clear: MoE is increasingly standard for scaling capacity while keeping inference costs low, more efficient attention variants like Grouped-Query Attention, MLA, and sliding window attention are replacing classic Multi-Head Attention, and teams prioritize performance optimization over inventing radically new architectures. The article explains why equal parameter counts do not translate to equal operating costs.&lt;/p&gt;
&lt;h2 id="from-asyncawait-to-virtual-threads"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/26/virtual-threads/" rel="noopener noreferrer"&gt;From Async/Await to Virtual Threads&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask and Jinja, argues that Python&amp;rsquo;s &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; model pushes too much internal complexity onto users. The most visible symptom is &amp;ldquo;colored functions&amp;rdquo;: async functions and synchronous functions cannot call each other directly, splitting the library ecosystem in two. Task cancellation is also hard to get right—for instance, &lt;code&gt;aiofiles&lt;/code&gt; does not support proper cancellation and can hang under structured concurrency. As Python introduces free-threading, developers now have to worry about the pitfalls of both async and traditional multithreading at the same time.&lt;/p&gt;
&lt;p&gt;His proposal is virtual threads: lightweight threads managed by the runtime rather than the operating system, making blocking operations non-blocking transparently and eliminating the need for &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; keywords. Threads are organized into thread groups in the spirit of structured concurrency: child threads cannot outlive their parent, context variables are inherited automatically from parent to child, if one child thread fails the remaining siblings are cancelled, and the group finishes only when all child threads complete. The author stresses that this is a thought experiment to spark discussion, with many open questions around syntax and variable scoping in Python still unresolved; the snippet below illustrates downloading multiple URLs with at most 8 concurrent threads.&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;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-python" data-lang="python"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;download_all&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;urls&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="n"&gt;results&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;ThreadGroup&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;max_concurrency&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;8&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;url&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;urls&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;spawn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;partial&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;download_and_store&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;results&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="six-principles-for-production-ai-agents"&gt;&lt;del&gt;&lt;a href="https://www.app.build/blog/six-principles-production-ai-agents" rel="noopener noreferrer"&gt;Six Principles for Production AI Agents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;With the rapid rise of AI agents in real-world applications, taking them to production demands solid design principles. This article presents 6 core principles for building reliable AI agents in production environments:&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;1. Invest in the System Prompt&lt;/strong&gt;: Focus on clear, direct instructions. Modern models need detailed, non-contradictory context rather than clever prompt hacks.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;2. Separate Context&lt;/strong&gt;: Provide minimal initial knowledge and let tools fetch additional context on demand. Use &amp;ldquo;context compression&amp;rdquo; to manage complexity.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;3. Design Tools Carefully&lt;/strong&gt;: Build focused, thoroughly tested tools. Limit the number of tools, keep parameters explicit, and ensure idempotency.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;4. Design Feedback Loops&lt;/strong&gt;: Use an actor-critic approach that allows creative generation backed by strict verification, including domain-specific checks.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;5. Analyze Failures with LLMs&lt;/strong&gt;: Use multiple agents to analyze logs and execution trajectories, leveraging LLMs to pinpoint areas for improvement.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;6. Treat Frustrating Behavior as System Bugs&lt;/strong&gt;: Understand that agents may &amp;ldquo;hack&amp;rdquo; instructions. Debug the system design before blaming the model.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Key takeaway: &amp;ldquo;Building effective AI agents isn&amp;rsquo;t about finding a silver bullet&amp;hellip; it&amp;rsquo;s about sound system design and software engineering.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="working-effectively-with-ai-coding-tools-like-claude-code"&gt;&lt;a href="https://sajalsharma.com/posts/effective-ai-coding/" rel="noopener noreferrer"&gt;Working Effectively with AI Coding Tools like Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sajal Sharma distills best practices for working effectively with AI coding tools like Claude Code, starting from a clear premise: AI excels at implementation, while humans must own architecture, judgment, and strategy. The center of gravity therefore shifts from writing code to writing specifications: settle architectural questions first, check detailed specs into version control, and only then let AI implement them. Treat AI like a talented pair programmer who lacks business context—read every line of code it generates and watch out for shortcuts like overusing TypeScript&amp;rsquo;s &lt;code&gt;any&lt;/code&gt; or patching symptoms instead of root causes, because AI generates code faster than humans can review it.&lt;/p&gt;
&lt;p&gt;On workflow, the author recommends writing highly specific prompts, always asking the AI why it chose a given approach, and using a second model to cross-check complex decisions. Have the AI draft a plan first, review it carefully, save it as a markdown file to track progress, and start a fresh chat for each feature since long conversations degrade consistency. With Claude Code, &lt;code&gt;CLAUDE.md&lt;/code&gt; serves as a map pointing to architecture docs, API specs, and active plans; shared slash commands in &lt;code&gt;.claude/commands/&lt;/code&gt; standardize workflows across the team; and specialized subagents for planning, implementation, review, and research keep each agent&amp;rsquo;s context lean. The productivity gains are real, but only when quality is guarded through constant vigilance.&lt;/p&gt;
&lt;h2 id="when-software-engineers-think-they-need-more-focus-time"&gt;&lt;a href="https://jola.dev/posts/enough-focus-time" rel="noopener noreferrer"&gt;When Software Engineers Think They Need More Focus Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jola&amp;rsquo;s article challenges the common belief that software engineers always need more uninterrupted focus time to write code. In the author&amp;rsquo;s view, an engineer&amp;rsquo;s job is to create impact, solve problems, and deliver real value—and the highest-value work often happens outside the code editor: catching a flawed assumption in a product meeting before the whole project veers off course, asking a clarifying question that saves the team weeks of effort, pairing with a stuck junior teammate, or reviewing a design doc before implementation begins. Engineers who block off their calendars to code in isolation easily miss these exact opportunities for leverage.&lt;/p&gt;
&lt;p&gt;The author doesn&amp;rsquo;t dismiss focus time, but advises using it intentionally: measure productivity by value delivered rather than hours spent coding, communicate your schedule clearly (for instance, deep work in the morning, available to help in the afternoon), continually ask whether you are solving the right problem, and remember that an engineer&amp;rsquo;s impact extends beyond source code. The core spirit of the piece can be summed up in one sentence: the goal is not to write code; the goal is to solve problems.&lt;/p&gt;
&lt;h2 id="making-postgres-42000x-slower-because-i-am-unemployed"&gt;&lt;a href="https://byteofdev.com/posts/making-postgres-slow/" rel="noopener noreferrer"&gt;Making Postgres 42,000x slower because I am unemployed&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A hilarious yet educational experiment: the author sets a rule that only &lt;code&gt;postgresql.conf&lt;/code&gt; may be modified and the database must still complete at least one transaction within a reasonable time, then tries to make PostgreSQL as slow as humanly possible. The benchmark is TPC-C with 128 warehouses run via BenchBase across 100 connections on a Ryzen 7950X with 32GB of RAM. Starting from a baseline of roughly 7,082 transactions per second, shrinking &lt;code&gt;shared_buffers&lt;/code&gt; down to a few megabytes forces constant reads through the OS and drops throughput to a few hundred TPS; configuring autovacuum to run continuously with ultra-low thresholds pushes it down to about 293; forcing constant WAL checkpoints with full sync brings it down to around 98.&lt;/p&gt;
&lt;p&gt;The final two steps hit hardest: tweaking planner cost parameters like &lt;code&gt;random_page_cost&lt;/code&gt; so the query planner virtually refuses to use indexes drops throughput below 1 TPS; then setting &lt;code&gt;io_method&lt;/code&gt; and &lt;code&gt;io_workers = 1&lt;/code&gt; in a new development build of PostgreSQL funnels all I/O through a single worker, bringing reported throughput down to 0.016 TPS. Compared to 7,082, that is a slowdown of roughly 440,000x. Read in reverse, the post is a hands-on lesson in what each setting actually does: buffer pools, autovacuum, WAL, planner cost constants, and parallel I/O all have massive performance impacts and should be tuned to real workloads rather than tweaked blindly.&lt;/p&gt;
&lt;h2 id="stack-overflow-developer-survey-2025"&gt;&lt;a href="https://survey.stackoverflow.co/2025/" rel="noopener noreferrer"&gt;Stack Overflow Developer Survey 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stack Overflow&amp;rsquo;s 15th annual Developer Survey gathered over 49,000 responses from 177 countries, covering 62 questions across 314 technologies. The standout finding is the gap between AI adoption and trust: 84% of respondents use or plan to use AI tools, and 47% use them daily, yet only about a third trust their accuracy while 46% actively distrust them. The biggest frustration (66%) is solutions that are &amp;ldquo;almost right, but not quite,&amp;rdquo; followed by the difficulty of debugging AI-generated code; most developers are also not using AI agents yet.&lt;/p&gt;
&lt;p&gt;On the technology front, Python jumped 7 percentage points to 57.9%, a rise the report links to AI and data science; JavaScript remains on top, and Visual Studio Code continues as the most popular IDE; OpenAI&amp;rsquo;s GPT models are the most used while Claude Sonnet is the most admired, and Rust&amp;rsquo;s Cargo is the most admired infrastructure tool. On the career side, only about 24% of developers report being happy at work (up from the previous year), roughly a third work fully remote, and &amp;ldquo;architect&amp;rdquo; entered the top four most common roles for the first time. For junior developers, this offers a useful compass: AI has become an everyday tool, but the ability to verify its output is what sets engineers apart.&lt;/p&gt;
&lt;h2 id="choose-boring-technology-revisited"&gt;&lt;a href="https://www.brethorsting.com/blog/2025/07/choose-boring-technology,-revisited/" rel="noopener noreferrer"&gt;Choose Boring Technology, Revisited&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aaron Brethorst revisits Dan McKinley&amp;rsquo;s 2015 classic &amp;ldquo;Choose Boring Technology&amp;rdquo; and argues that the principle matters even more in the age of AI. The original idea is that every organization has a limited budget of &amp;ldquo;innovation tokens&amp;rdquo; to spend intentionally: use familiar tools when solving novel business problems, and accept only one new unknown at a time when learning. &amp;ldquo;Boring&amp;rdquo; technology has the advantage of well-understood failure modes, known capabilities, and proven operational reliability.&lt;/p&gt;
&lt;p&gt;The new twist is that AI assistants can generate professional-looking code for any tech stack imaginable, creating a false sense of confidence. When you combine multiple unfamiliar technologies with AI-written code, you lose the ability to verify the output: you don&amp;rsquo;t know whether the framework choice makes sense, nor what failure modes to watch out for. Therefore, before introducing a new technology into a project, ask yourself whether you are qualified to review AI-generated code in that stack; invest the time to understand a new tool deeply enough to audit AI&amp;rsquo;s suggestions; and don&amp;rsquo;t use AI as an excuse to adopt several unfamiliar technologies at once. As the author puts it, AI should be a force multiplier for technologies you already understand, not a crutch for ones you don&amp;rsquo;t.&lt;/p&gt;
&lt;h2 id="agentic-coding-things-that-didn"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/30/things-that-didnt-work/" rel="noopener noreferrer"&gt;Agentic Coding Things That Didn&amp;rsquo;t Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In contrast to typical success stories, Armin Ronacher shares the AI agent automations he tried and ultimately abandoned. None of his custom slash commands survived: &lt;code&gt;/fix-bug&lt;/code&gt; was no better than pasting a GitHub issue link with his own thoughts, &lt;code&gt;/commit&lt;/code&gt; never matched his commit message style, &lt;code&gt;/add-tests&lt;/code&gt; and &lt;code&gt;/fix-nits&lt;/code&gt; were worse or redundant compared to plain prompts, and &lt;code&gt;/next-todo&lt;/code&gt; went practically unused. Hooks proved awkward to control and ran formatters after every edit rather than at the end of a session, so he switched to intercepting commands via &lt;code&gt;PATH&lt;/code&gt; for simplicity; print mode (90% deterministic code, 10% inference) looks promising but remains slow and hard to debug; subagents help parallelize work but create messes when reading and writing simultaneously, so he usually opens separate sessions or shares context via markdown files instead.&lt;/p&gt;
&lt;p&gt;What actually worked turned out to be remarkably simple: talking to the machine via speech-to-text to convey richer context, manually copying and pasting curated context, and letting the agent read &lt;code&gt;git status&lt;/code&gt; to figure out which files need attention. The most important warning in the article is that automating through LLMs easily tempts users to stop thinking like engineers—at which point quality drops, time is wasted, and you neither understand the system nor learn anything. His rules of thumb: only automate tasks you do constantly, delete unused automations immediately, and evaluate outputs critically before trusting them.&lt;/p&gt;
&lt;h2 id="vibe-code-is-legacy-code"&gt;&lt;a href="https://blog.val.town/vibe-code" rel="noopener noreferrer"&gt;Vibe Code is Legacy Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Krouse of Val Town reminds readers that Andrej Karpathy coined &amp;ldquo;vibe coding&amp;rdquo; to describe a style of coding with AI where you &amp;ldquo;forget that the code even exists.&amp;rdquo; And code that nobody understands already has a name: legacy code. Programming is fundamentally theory-building rather than line-of-code production, so when you vibe code, you accumulate technical debt at the exact speed the LLM generates tokens. That makes vibe coding a great fit for prototypes and throwaway projects—like small apps the author built to calculate growth rates or propose to his partner—because code only becomes a burden when you have to maintain it. Vibe coding is also a spectrum: the better you understand the code, the less you are &amp;ldquo;vibing.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The worst-case scenario is a non-programmer vibe-coding a large project meant to be maintained long-term, which is like handing a credit card to a child without explaining debt: exciting at first, until the bill arrives a month later, and asking AI to fix the bugs at that point is like paying off one credit card with another. For serious projects, the author agrees with Karpathy: keep AI on a tight leash like an overeager intern, move deliberately, and use every opportunity to learn. Val Town uses its assistant Townie both ways—sometimes to vibe code, sometimes to make surgical edits in production projects—and the author believes theory-building will remain at the heart of complex software development.&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 #48</title><link>https://miti99.com/en/post/2025/08/07/</link><pubDate>Thu, 07 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #48.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="todos-aren"&gt;&lt;a href="https://sophiebits.com/2025/07/21/todos-arent-for-doing" rel="noopener noreferrer"&gt;TODOs aren&amp;rsquo;t for doing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sophie Alpert pushes back against two common policies for handling &lt;code&gt;TODO&lt;/code&gt; comments in codebases: requiring every &lt;code&gt;TODO&lt;/code&gt; to have a corresponding ticket in an issue tracker, or automatically deleting &lt;code&gt;TODO&lt;/code&gt;s that have sat around too long. In her view, only urgent &lt;code&gt;TODO&lt;/code&gt;s like &amp;ldquo;Finish writing the second half of this file so next week&amp;rsquo;s launch doesn&amp;rsquo;t crash&amp;rdquo; actually need to be tracked as tasks. The most valuable &lt;code&gt;TODO&lt;/code&gt;s aren&amp;rsquo;t meant to be done at all: they document edge cases and design hints, such as &amp;ldquo;if the user clicks this button three times in a row, the event handler will break&amp;rdquo;—a rare scenario the author noticed but didn&amp;rsquo;t need to fix yet.&lt;/p&gt;
&lt;p&gt;The real value of these comments is preserving the original author&amp;rsquo;s train of thought and context. When another developer reads the code later and wonders whether a structure could be written differently, a well-placed &lt;code&gt;TODO&lt;/code&gt; answers that question immediately, giving them the confidence to refactor instead of hesitating out of fear that the original author knew something they didn&amp;rsquo;t. For junior developers, this is a helpful perspective: treat &lt;code&gt;TODO&lt;/code&gt;s as small notes left for future readers rather than a backlog of chores that must be swept clean.&lt;/p&gt;
&lt;h2 id="automating-away-claude"&gt;&lt;a href="https://writeaheadblogg.ing/posts/claude-hooks-auto-fix-trailing-whitespace/" rel="noopener noreferrer"&gt;Automating Away Claude&amp;rsquo;s Bad Habits with Hooks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code frequently leaves trailing whitespace at the end of lines because language models generate text token by token without &amp;ldquo;seeing&amp;rdquo; the rendered formatting, and telling it not to in instructions is unreliable. Brian Cosgrove solves this cleanly using hooks—user-defined shell commands that run automatically at specific points in Claude&amp;rsquo;s workflow loop. Specifically, he configures a &lt;code&gt;PostToolUse&lt;/code&gt; hook that runs RuboCop with the &lt;code&gt;Layout/TrailingWhitespace&lt;/code&gt; rule every time Claude edits a Ruby file. He deliberately chooses a language-aware linter over a generic &lt;code&gt;sed&lt;/code&gt; or regex replacement, which could corrupt binary files or break trailing-space line breaks in Markdown and other whitespace-sensitive formats.&lt;/p&gt;
&lt;p&gt;Beyond &lt;code&gt;PostToolUse&lt;/code&gt;, hooks also support &lt;code&gt;PreToolUse&lt;/code&gt;, &lt;code&gt;Notification&lt;/code&gt;, &lt;code&gt;Stop&lt;/code&gt;, and &lt;code&gt;SubagentStop&lt;/code&gt; events, allowing you to inspect, transform, or block actions at various stages: running linters, executing tests, verifying that code compiles, or preventing risky operations like committing untested code. The author also warns that hooks run with the user&amp;rsquo;s full permissions, so you should read every command carefully before adding it, as a malicious hook could compromise your system during routine Claude operations. This is a practical example of turning AI&amp;rsquo;s &amp;ldquo;bad habits&amp;rdquo; into automatically corrected steps rather than repeating yourself in prompts.&lt;/p&gt;
&lt;h2 id="docs-for-ai-agents"&gt;&lt;del&gt;&lt;a href="https://technicalwriting.dev/ai/agents/" rel="noopener noreferrer"&gt;Docs for AI Agents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Kayce Basques shares thoughts on documentation written for AI agents and how it relates to internal technical documentation that engineering teams write for themselves, such as RFCs or build guides. Agent docs make agent outputs more consistent, aligned with project conventions, and accurate: when first using Claude Code, the author noticed the tool correctly guessed the site used Sphinx built with Bazel, but ran the wrong command; adding the right command to the agent doc fixed it permanently. Each tool looks for its own root file (&lt;code&gt;CLAUDE.md&lt;/code&gt; for Claude Code, &lt;code&gt;GEMINI.md&lt;/code&gt; for Gemini CLI, &lt;code&gt;AGENTS.md&lt;/code&gt; for Codex CLI), and the file&amp;rsquo;s contents are injected verbatim into the system prompt on every model call, so it needs to stay concise. Subdirectory and user-level agent docs are also supported.&lt;/p&gt;
&lt;p&gt;The big question is whether to maintain two separate sets of documentation. Reasons to keep them separate include different writing styles, agents&amp;rsquo; need for brevity versus humans&amp;rsquo; need for comprehensive context, and the fact that models already know many general concepts; the reason to merge them is avoiding duplication and drift over time. The author suggests several approaches: using AI itself to keep the two sets in sync, merging them into one, embedding agent instructions as comments inside human docs and extracting them via a script, using &lt;code&gt;@&lt;/code&gt; imports to pull in files like &lt;code&gt;CONTRIBUTING.md&lt;/code&gt;, or using pre-merge checks to enforce that related files are updated together.&lt;/p&gt;
&lt;h2 id="developers-are-using-these-ai-agents-to-build-software-10x-faster"&gt;&lt;a href="https://dev.to/therealmrmumba/developers-are-using-these-ai-agents-to-build-software-10x-faster-efn" rel="noopener noreferrer"&gt;Developers Are Using These AI Agents to Build Software 10x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article rounds up AI coding agents that are helping developers move significantly faster in 2025, with brief descriptions of how each tool automates parts of the workflow. The list includes Cursor (an AI-first editor with real-time suggestions), Emergent (multi-agent orchestration for generating features and preparing deployments), DeepDocs (automatically syncing GitHub documentation with code changes via GitHub Actions), Continue.dev (an open-source platform for building custom AI-integrated IDEs), ByteDance&amp;rsquo;s Trae (end-to-end web app development with multimodal input support), Cline (a VS Code extension built for large codebases), Google&amp;rsquo;s Gemini CLI and Sourcegraph&amp;rsquo;s Cody CLI (in-terminal assistants), OpenHands (an autonomous open-source agent framework), Replit AI (a cloud environment with built-in database support), Augment Code (an IDE-integrated agent that can run code and spot performance issues), and CodeRabbit (automated GitHub pull request reviews).&lt;/p&gt;
&lt;p&gt;The central message is that these agents take over repetitive tasks, enabling faster delivery and cleaner code for solo developers, startups, and large enterprises alike. The author concludes that adopting a few such tools in your 2025 workflow is shifting from a productivity boost to a necessity. For newer developers, it serves as a handy survey for picking tools to try out.&lt;/p&gt;
&lt;h2 id="what-kind-of-work-i-want-in-2025"&gt;&lt;a href="https://www.seangoedecke.com/my-engineering-values-2025/" rel="noopener noreferrer"&gt;What kind of work I want (in 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke candidly lists the kind of engineering work he wants in 2025—a great template for any engineer thinking deliberately about their career path. On work environment, he prioritizes fully remote roles with occasional in-person gatherings over mandatory hybrid policies; he prefers low-process management that trusts engineers without heavy scrum ceremonies, and wants to stay based in Australia. On projects, he looks for work at the core of the business that leadership cares about, including unglamorous systems like billing; he excels at getting things done inside large monolithic codebases and prefers iteratively improving an imperfect solution over polishing indefinitely.&lt;/p&gt;
&lt;p&gt;He targets large US tech companies or comparable Australian firms, avoids startups, wants to work on large-scale systems people have heard of, and is currently very interested in AI both as a tool and as a transformative technology. His ethical boundaries are explicit: no proof-of-work blockchain, online gambling, autonomous weapons, or predatory financial services, alongside a strong preference for diverse teams. The biggest shift since 2021 is abandoning the idea of building a safe career maintaining legacy systems—since those roles are prime targets during layoffs—in favor of high-priority initiatives; his expectations of managers have also simplified down to competence and honesty.&lt;/p&gt;
&lt;h2 id="welcoming-the-next-generation-of-programmers"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/20/the-next-generation/" rel="noopener noreferrer"&gt;Welcoming The Next Generation of Programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that AI coding tools will expand rather than shrink the programming profession: AI will not reduce the number of programmers—in fact, the opposite seems much more likely. His definition is deliberately inclusive: &amp;ldquo;If you create a program, whether by hand or with the help of an agent, you are a programmer.&amp;rdquo; He sees growing consensus that newcomers will and should write AI-generated code, and points to the Python community&amp;rsquo;s tradition of openness—through initiatives like PyLadies—as a model for welcoming this new wave of learners.&lt;/p&gt;
&lt;p&gt;The challenge he highlights is that whereas new programmers used to learn alongside human mentors, those learning through ChatGPT may lack human connection altogether. Rather than looking down on &amp;ldquo;vibe coders,&amp;rdquo; the community should actively mentor them and build pathways into the broader ecosystem, so tooling companies don&amp;rsquo;t turn them into dependent users with no incentive to learn deeper fundamentals. The goal is to turn isolated human-AI interactions into a shared learning journey that helps the next generation develop sound software engineering practices.&lt;/p&gt;
&lt;h2 id="pattern-matching-across-different-languages"&gt;&lt;a href="https://blog.frankel.ch/pattern-matching-different-languages/" rel="noopener noreferrer"&gt;Pattern-matching across different languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel compares how pattern matching is supported across Java, Scala, Kotlin, Python, and Rust, starting from the traditional C-style &lt;code&gt;switch&lt;/code&gt; statement. Every example uses the same geometric hierarchy of &lt;code&gt;Rectangle&lt;/code&gt; and &lt;code&gt;Circle&lt;/code&gt; with a perimeter function, combining type matching and pattern guards to detect when a rectangle is a square. Java 23 uses &lt;code&gt;switch&lt;/code&gt; expressions with arrow syntax, supporting type patterns and &lt;code&gt;when&lt;/code&gt; guards, selecting the first matching branch. Kotlin uses &lt;code&gt;when&lt;/code&gt; expressions and &lt;code&gt;is&lt;/code&gt; checks, with the article&amp;rsquo;s example enabling an experimental flag for guards. Python added the &lt;code&gt;match&lt;/code&gt; statement in 3.10, which destructures attributes by name very cleanly. The Rust translation uses trait objects and downcasting, making it more verbose; the author explicitly notes that this setup is not idiomatic and does not reflect Rust&amp;rsquo;s true pattern-matching strengths.&lt;/p&gt;
&lt;p&gt;Among the languages compared, Scala pioneered pattern matching early on and still stands out for destructuring and extracting class fields directly inside a match arm without extra variable bindings; it inspired the other languages, though the author notes Java and Kotlin have largely closed the gap in this example. He concludes that pattern matching combined with destructuring makes code significantly more readable and maintainable—a technique well worth learning in any modern language.&lt;/p&gt;
&lt;h2 id="a-real-world-ai-coding-case-sample"&gt;&lt;a href="https://blog.korny.info/2025/07/18/a-real-world-ai-coding-case-sample" rel="noopener noreferrer"&gt;A real-world AI coding case sample&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny shares a real-world walkthrough of using Claude to add a feature to an ASP.NET Core application: publishing a &lt;code&gt;PersonBusinessLink&lt;/code&gt; event to Kafka with a &amp;ldquo;linked&amp;rdquo; or &amp;ldquo;unlinked&amp;rdquo; type whenever a contact person is associated with or removed from a business. The project uses monadic &lt;code&gt;Result&lt;/code&gt; and &lt;code&gt;Option&lt;/code&gt; return types, domain-driven design with repositories and services, and Kafka running in Docker with Testcontainers for integration tests. Rather than letting Claude run on autopilot, he guided it step by step: first asking it to identify existing patterns in the codebase, then requesting the feature with a detailed spec, reviewing every change before committing, and stepping in when Claude picked the wrong Kafka topic or partition key. When Claude struggled with the monadic control flow, he debugged it himself rather than letting it spin its wheels.&lt;/p&gt;
&lt;p&gt;Claude did well at learning test conventions from existing files and handling straightforward boilerplate, but needed course correction on architectural decisions and couldn&amp;rsquo;t resolve deeper bugs on its own. The author&amp;rsquo;s advice is to treat AI like a very fast, enthusiastic, but naive junior developer: useful when carefully guided, but not reliably autonomous on complex tasks. He also raises serious concerns about the environmental cost, unsustainable venture funding, and the motives of the companies behind these tools.&lt;/p&gt;
&lt;h2 id="clowns-to-the-left-of-me"&gt;&lt;a href="https://blog.korny.info/2025/07/19/clowns-to-the-left-of-me" rel="noopener noreferrer"&gt;Clowns to the Left of Me&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny reflects on the polarized debate around AI coding tools and places himself squarely in the middle, echoing the song &amp;ldquo;Stuck in the Middle With You&amp;rdquo; referenced in the title. On one side are the hype evangelists claiming 50x productivity gains, advocating coding without regard for security, and getting swept up in the thrill of rapid code generation—leading them to overstate capabilities and downplay risks. On the other side are the skeptics, who are right to push back against exaggerated claims, but sometimes treat preliminary studies as definitive proof and dismiss the tools after a few low-context tries.&lt;/p&gt;
&lt;p&gt;The author takes a pragmatic view: the tools genuinely help him in real work—such as writing Python scripts, generating diagrams for documentation, or spotting security vulnerabilities—but require careful prompting, output verification, and choosing the right use cases. What matters is learning when and how to use them effectively; he recommends following balanced practitioners like Simon Willison and Birgitta Böckeler. Still, he stresses that we shouldn&amp;rsquo;t ignore systemic issues: massive energy consumption, environmental harm tied to fossil fuels, unsustainable VC subsidies, and power concentrated in the hands of controversial tech leaders. Bottom line: evaluate the tools through evidence and hands-on experience.&lt;/p&gt;
&lt;h2 id="improving-the-prompt-to-the-ai-to-get-better-code"&gt;&lt;a href="https://blog.vanillajava.blog/2025/07/improving-prompt-to-ai-to-get-better.html" rel="noopener noreferrer"&gt;Improving the prompt to the AI to get better code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of Vanilla Java Blog experiments with optimizing a Java method that formats a time zone offset from milliseconds into ISO 8601 (&lt;code&gt;±hh&lt;/code&gt;, &lt;code&gt;±hhmm&lt;/code&gt;, or &lt;code&gt;±hhmmss&lt;/code&gt;) while allocating as few objects as possible for low-latency applications. Initial &amp;ldquo;one-shot&amp;rdquo; prompts produced wildly uneven results across models. A refined prompt spelled out explicit constraints: use a &lt;code&gt;ThreadLocal&lt;/code&gt; buffer, stick to simple arithmetic, avoid &lt;code&gt;String.format&lt;/code&gt; and object allocations, and return an &lt;code&gt;intern()&lt;/code&gt;ed string. This guidance helped weaker models improve dramatically.&lt;/p&gt;
&lt;p&gt;Seven systems were evaluated: Gemini 2.5 Pro, o3-pro, o4-mini-high, Claude 4, Grok 3 Think, GitHub Copilot with GPT-4.1, and Microsoft Copilot in Think Deeper mode. Response times ranged from a few seconds to 18 minutes without a corresponding jump in quality. Most solutions used a &lt;code&gt;ThreadLocal&lt;/code&gt; &lt;code&gt;char[]&lt;/code&gt; buffer and manipulated digits directly, but not a single model suggested using &lt;code&gt;byte[]&lt;/code&gt;, even though modern Java strings store characters internally as a byte array. The takeaways: detailed prompts narrow the gap between models, longer thinking time does not guarantee better code, and AI can still miss specialized performance tricks; the best approach is testing multiple models and iterating on the prompt rather than asking just once.&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 #45</title><link>https://miti99.com/en/post/2025/08/04/</link><pubDate>Mon, 04 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/04/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was put together using Cline + Kimi K2.&lt;/del&gt; Enjoy Newsletter #45.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-best"&gt;&lt;a href="https://www.paulgraham.com/best.html" rel="noopener noreferrer"&gt;The Best&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his essay &amp;ldquo;The Best Essay,&amp;rdquo; Paul Graham asks: what would the best possible essay look like? His first answer is that it must tackle the most important topic about which one can still say something surprising—but that line of thought leads toward major scientific discoveries, which are tied to the moment of their discovery rather than being timeless. So he reframes it into a more practical question: how do you write a truly great essay? According to Graham, everything starts with a compelling initial question where the writer has a fresh perspective or a distinct approach.&lt;/p&gt;
&lt;p&gt;The writing process turns vague ideas into concrete prose, followed by ruthless rereading and revision until the gap between the current answer and the truth becomes visible—sometimes opening up an entirely new direction. An essay works like a recursive exploration: each answer spawns new questions, and the writer should follow whichever branch offers the best combination of generality and novelty, ready to discard whole passages already written if they no longer serve the main thread. Although the initial question caps the maximum quality of the essay, Graham advises against being overly cautious when choosing topics; instead, write a lot, because most questions can yield a good essay. The ability to ask great questions comes from broad knowledge and deep experience across multiple fields.&lt;/p&gt;
&lt;h2 id="ai-tools-make-developers-19-slower-not-faster"&gt;&lt;a href="https://threadreaderapp.com/thread/1943360399220388093.html" rel="noopener noreferrer"&gt;AI Tools Make Developers 19% Slower, Not Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The research organization METR conducted a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories, which averaged over 22,000 stars and more than one million lines of code. Each task was randomly assigned to either allow or disallow AI tools (primarily Cursor Pro with Claude 3.5/3.7). The results were surprising: before the experiment, developers predicted AI would make them 24% faster; after finishing, they still felt they had been 20% faster; yet the actual measurements showed they were 19% slower when assisted by AI.&lt;/p&gt;
&lt;p&gt;The researchers emphasize that these findings apply specifically to this setting and do not represent the entire software industry; future models or more effective usage patterns could yield different outcomes. The slowdown appeared consistently across multiple metrics and stemmed from several factors at once: when allowed to use AI, developers spent time prompting the AI, waiting for responses, reviewing AI output, and idling, rather than directly writing code or looking up documentation. The takeaway is that the gap between subjective perception and actual productivity can be huge, so measure rather than relying on gut feeling when evaluating new tools.&lt;/p&gt;
&lt;h2 id="evolution-of-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/evolution-of-ubers-search-platform/" rel="noopener noreferrer"&gt;Evolution of Uber&amp;rsquo;s Search Platform&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article recounts the three-stage evolution of Uber&amp;rsquo;s search platform. Initially, Uber treated Elasticsearch (built on Apache Lucene) almost as a &amp;ldquo;black box,&amp;rdquo; with engineers focused mainly on keeping operations stable. A major limitation was Lucene&amp;rsquo;s near-real-time mechanism: new data became searchable only after being flushed to the index, introducing latency in time-sensitive scenarios like matching riders with drivers. Starting in 2019, Uber built Sia in-house, extending Lucene with an in-memory live index for real-time search, switching to lighter-weight gRPC/Protobuf communication, pull-based ingestion via Kafka, and active-active multi-region deployment. However, the complex custom architecture made it very difficult to adopt new Lucene features such as vector search, while most use cases didn&amp;rsquo;t actually need real-time freshness.&lt;/p&gt;
&lt;p&gt;In 2024, with Project Sunrise, Uber recognized that maintaining a custom fork was no longer sustainable and migrated to OpenSearch, becoming a founding member of the OpenSearch Software Foundation. The current architecture separates the write path from the read path: data from Kafka is compacted into optimized segments and uploaded to remote storage, while search nodes simply download them to serve queries, keeping all ingestion overhead off the query path. Uber also contributed features back to OpenSearch 3.0, including pull-based ingestion and gRPC APIs. The lesson: custom-built solutions are expensive to maintain when the ecosystem moves fast, and complexity should only be accepted where it is genuinely needed.&lt;/p&gt;
&lt;h2 id="vercel"&gt;&lt;a href="https://leerob.com/vercel" rel="noopener noreferrer"&gt;Vercel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson reflects on his five years at Vercel, where he grew from an individual engineer to VP, watching the company scale from 30 people and $1 million in ARR to 650 people and over $200 million. His first lesson is work-life balance: he once answered work messages even during his honeymoon, and only broke free by building processes and hiring people capable enough to run things themselves. Second, speed is a competitive advantage: asking &amp;ldquo;what would it take to ship this next week?&amp;rdquo; forces teams to find creative solutions, and even if you miss the deadline, you still finish faster than if you had set none at all.&lt;/p&gt;
&lt;p&gt;Third, scaling requires hiring rather than doing everything yourself—always be recruiting, keep the bar high, and only hire candidates who genuinely excite you. Fourth, avoid unilateral decisions: he once parachuted into a product launch at the last minute and demanded changes without full context, something he regrets; leaders should get involved early and build consensus before making calls. Finally, stay adaptable and admit mistakes: personally reviewing every company social media post created a bottleneck, and delegating ownership alongside clear quality guidelines produced better results. These are valuable lessons for any developer moving toward a leadership role.&lt;/p&gt;
&lt;h2 id="tools"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/3/tools/" rel="noopener noreferrer"&gt;Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that when working with AI agents, &amp;ldquo;code is all you need.&amp;rdquo; He critiques the MCP protocol, which lets language models invoke external tools and services: this approach is hard to compose because every step depends on model inference, consumes substantial context on each tool call, and scales poorly when automating repetitive tasks. In his view, without AI, a software engineer solves problems by writing code—so AI should do the same.&lt;/p&gt;
&lt;p&gt;Model-generated code has explicit logic that humans can inspect, runs repeatedly at low cost once written, and is easier to debug. As an illustration, Armin describes migrating his entire blog from reStructuredText to Markdown: the model wrote AST-based conversion scripts, wrote additional scripts comparing the old and new HTML to verify the output, and iterated on that feedback loop with almost no human intervention. Here, the model acted as a code quality evaluator rather than manually executing each step. He concludes that MCP looks like a dead end for large-scale automation, and a more promising path is combining code generation with having the model evaluate the results after execution.&lt;/p&gt;
&lt;h2 id="how-i-build-software-quickly"&gt;&lt;a href="https://evanhahn.com/how-i-build-software-quickly/" rel="noopener noreferrer"&gt;How I Build Software Quickly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn shares how he builds software quickly while maintaining acceptable quality. The core principle is balancing speed and quality: aim for &amp;ldquo;8 out of 10, delivered on time&amp;rdquo; rather than chasing perfection. What counts as &amp;ldquo;good enough&amp;rdquo; depends on context—a 24-hour game jam tolerates messy code, whereas a pacemaker demands excellence—so you need to understand what your team considers good enough. He recommends building a rough draft first, full of TODOs, hardcoded data, and unhandled errors, to uncover unforeseen problems early, avoid wasting effort on code that will be thrown away, and prevent premature abstraction.&lt;/p&gt;
&lt;p&gt;Doing less is also a way to move faster: question the scope, combine screens, skip unnecessary edge cases, or trim API parameters. To stay focused, he sets timers for tasks and pair-programs. Small changes are easier to write, review, revert, and debug—for instance, fixing a bug, upgrading a library, and adding a feature in separate changes. The skills that speed him up most include reading code (the most important one), data modeling, writing automation scripts, using a debugger, taking breaks, writing pure functions, and leveraging LLM tools.&lt;/p&gt;
&lt;h2 id="the-most-mysterious-bug-i-solved-at-work"&gt;&lt;a href="https://cadence.moe/blog/2025-07-02-the-most-mysterious-bug-i-solved-at-work/" rel="noopener noreferrer"&gt;The Most Mysterious Bug I Solved at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cadence recounts the most mysterious bug she ever solved on an electronic patient referral application in Australia, a system that converts referral data into HL7, CDA, or PDF formats to send to healthcare providers. Occasionally, the system threw the error &lt;code&gt;Illegal Character entity: expansion character (code 0x2) not a valid XML character&lt;/code&gt;. Character &lt;code&gt;0x2&lt;/code&gt; (Start of Text) is an obsolete control character from the early days of computing with virtually no modern use—yet it was showing up inside referral letters typed by doctors.&lt;/p&gt;
&lt;p&gt;Investigation gradually uncovered the clues: the affected letters all had unusual hard line breaks, and the same doctor was submitting identical letters multiple times. It turned out the doctor was copying text from PDFs of previous referrals stored in their practice management software, and character &lt;code&gt;0x2&lt;/code&gt; appeared right where hyphens sat at the ends of lines in the PDF. The culprit was Microsoft Edge&amp;rsquo;s built-in PDF viewer—the default on Windows—which mistakenly converted end-of-line hyphens into &lt;code&gt;0x2&lt;/code&gt; when copying text. The team fixed the issue by automatically replacing &lt;code&gt;0x2&lt;/code&gt; with a hyphen rather than stripping it, preserving the intended text. The story reminds developers that the root cause of a bug sometimes lies outside the codebase, in users&amp;rsquo; habits and the tools they rely on.&lt;/p&gt;
&lt;h2 id="how-to-think-about-time-in-programming"&gt;&lt;a href="https://shanrauf.com/archive/how-to-think-about-time-in-programming" rel="noopener noreferrer"&gt;How to Think About Time in Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shan Rauf lays out a clear mental model for handling time in programming. The foundation is absolute time, consisting of &amp;ldquo;instants&amp;rdquo; and &amp;ldquo;durations&amp;rdquo;: an instant is represented as seconds elapsed since a reference point called an epoch (Unix uses January 1, 1970), while a duration is the length of time between two instants, so comparisons and calculations require only basic arithmetic. Humans, however, use civil time based on the Gregorian calendar, with months of varying lengths. UTC defines the second using atomic clocks and occasionally inserts leap seconds to stay aligned with Earth&amp;rsquo;s rotation, meaning a day can be 86,401 or 86,399 seconds long; JavaScript&amp;rsquo;s &lt;code&gt;Date&lt;/code&gt; ignores leap seconds. Time zones are not fixed offsets but evolving sets of rules: during daylight saving transitions, certain civil times are skipped or repeated twice, and the IANA time zone database (such as &lt;code&gt;America/New_York&lt;/code&gt;) records known rules and historical transitions, though it does not guarantee accuracy for every location prior to 1970.&lt;/p&gt;
&lt;p&gt;In practice, chat messages should be stored in UTC and displayed in the viewer&amp;rsquo;s local time zone. For events, intent matters: a class held at a physical location should be stored as local time plus a time zone identifier, whereas an absolute event like a solar eclipse should be stored in UTC. The author recommends bundling the IANA database and updating it regularly, using Unicode CLDR data to display friendly time zone names, and never assuming a UTC offset is immutable. The advice &amp;ldquo;just use UTC&amp;rdquo; isn&amp;rsquo;t enough, because converting to UTC too early discards information about the user&amp;rsquo;s original intent.&lt;/p&gt;
&lt;h2 id="phrase-origin-why-do-we"&gt;&lt;a href="https://quuxplusone.github.io/blog/2025/04/04/etymology-of-call/" rel="noopener noreferrer"&gt;Phrase origin: Why do we &amp;ldquo;call&amp;rdquo; functions?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arthur O&amp;rsquo;Dwyer investigates why we say we &amp;ldquo;call&amp;rdquo; a function. There are three intuitive hypotheses: calling as in visiting a friend (dropping by, staying a while, then leaving), calling as in summoning a servant to do a task, or calling on the telephone to ask a question and get an answer. The real answer is closest to the second hypothesis, but via a detour through library science: in closed-stack libraries, patrons &amp;ldquo;called for&amp;rdquo; books by their shelf mark—the term &amp;ldquo;call number&amp;rdquo; coined by Melvil Dewey in 1876. Early computer scientists borrowed this metaphor for subroutine libraries, where programmers &amp;ldquo;called&amp;rdquo; prewritten routines off the shelf much like a librarian retrieving a book by its call number.&lt;/p&gt;
&lt;p&gt;The timeline shows the evolution clearly: in 1947, John Mauchly wrote about subroutines being &amp;ldquo;called in&amp;rdquo; from a library on magnetic tape; in 1956, MANIAC II assembly used a &amp;ldquo;call number&amp;rdquo; to identify subroutines; in 1958, Fortran II introduced the &lt;code&gt;CALL&lt;/code&gt; statement, turning &amp;ldquo;call&amp;rdquo; into a runtime action; around 1959–1960, Algol and other languages adopted the term; in 1961, the verb phrase &amp;ldquo;call a subroutine&amp;rdquo; was first recorded in Burroughs documentation; and by 1963, modern usage had settled into MIT&amp;rsquo;s curriculum. The author concludes that Fortran II&amp;rsquo;s &lt;code&gt;CALL&lt;/code&gt; keyword is what cemented &amp;ldquo;call&amp;rdquo; as the standard verb for invoking a function.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing again with many URLs, it seems Cline + Kimi K2 overflowed its context window; after compacting, it forgot parts of the context and easily got confused, needing repeated reminders that this environment is Windows and requires PowerShell-compatible commands instead of Linux ones. On top of that, it made a few silly mistakes like summarizing&amp;hellip; the wrong URL :&amp;gt;&lt;/em&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 #44</title><link>https://miti99.com/en/post/2025/08/03/</link><pubDate>Sun, 03 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/03/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;As mentioned, today I&amp;rsquo;ll try writing the Newsletter with Roo Code. The first few entries will use Roo Code + Qwen 3 Coder.&lt;/del&gt; Enjoy Newsletter #44.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="cursor-unveils-game-changing-web-app-for-ai-coding-agents"&gt;&lt;a href="https://opentools.ai/news/cursor-unveils-game-changing-web-app-for-ai-coding-agents" rel="noopener noreferrer"&gt;Cursor Unveils Game-Changing Web App for AI Coding Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anysphere, the company behind the AI code editor Cursor, has launched a web app for managing AI coding agents right from the browser. Instead of opening an IDE, users can assign tasks to agents in natural language, track progress, and merge agent-generated code changes from any internet-connected device. The app complements the existing IDE rather than replacing it, and at launch is available only to Pro tier subscribers and above.&lt;/p&gt;
&lt;p&gt;The article also provides context: Cursor has surpassed $500 million in annual recurring revenue and is used by more than half of the Fortune 500, while Anysphere&amp;rsquo;s CEO predicts that by 2026, AI agents will handle roughly 20% of a software engineer&amp;rsquo;s workload. Although community feedback has been broadly positive, questions remain around handling large repositories, pricing, and privacy. For junior developers, this is a clear signal that delegating to and supervising AI agents is steadily becoming part of everyday work.&lt;/p&gt;
&lt;h2 id="the-heart-of-software-engineering-still-beats"&gt;&lt;a href="https://annievella.com/posts/the-heart-of-software-engineering-still-beats/" rel="noopener noreferrer"&gt;The Heart of Software Engineering Still Beats&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Vella argues that even as AI tools dramatically reshape how we build software, the core of the craft remains intact. In her view, writing code is fundamentally about modeling: forming a structured mental model of a process, system, or idea, and encoding it into something a computer can execute. Design is not a separate phase either, but happens continuously while writing code, testing, debugging, and operating real-world systems; it is this ongoing refinement of abstractions that defines an engineer&amp;rsquo;s craft.&lt;/p&gt;
&lt;p&gt;The article acknowledges that generative AI is triggering an identity crisis: the part of the job many engineers took the most pride in—turning thoughts into code—is now automated, leaving quite a few feeling like bystanders in their own work. Even so, the author sees this as an evolution rather than replacement: modeling skills are shifting to a higher level, from writing code to organizing context for AI tools, also known as context engineering. The joy of shaping invisible systems and watching ideas take form is still there; only the medium of expression has changed.&lt;/p&gt;
&lt;h2 id="expert-generalist"&gt;&lt;a href="https://martinfowler.com/articles/expert-generalist.html" rel="noopener noreferrer"&gt;Expert Generalist&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler, together with Unmesh Joshi and Gitanjali Venkatraman, argues that software organizations overvalue narrow specialization, whereas what truly drives modern software development is the &amp;ldquo;expert generalist&amp;rdquo;: someone with broad knowledge who can still go deep into a few selected areas. The article describes six traits of such people: curiosity to explore new technologies and business domains; willingness to collaborate and humility to learn from specialists when entering unfamiliar territory; customer focus to guide their curiosity; prioritizing foundational knowledge like enduring principles and design patterns over fleeting tools; possessing a blended skill set more complex than a simple T-shaped model; and having &amp;ldquo;empathy&amp;rdquo; for adjacent disciplines, much like a race car driver who understands the car without needing to be a mechanical engineer.&lt;/p&gt;
&lt;p&gt;For organizations, the authors recommend hiring for learning speed and collaboration rather than experience with a specific tool, encouraging staff to rotate across areas, pairing expert generalists with a few deep specialists for each core technology, and building training programs just as rigorous as specialist tracks—such as hands-on workshops building miniature versions of Kafka, Kubernetes, or Delta Lake to grasp their internal design patterns. Generalist capability should also be recognized in promotion criteria.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;The entries above were written using Roo Code with Qwen 3 Coder; overall it was relatively slow and consumed quite a lot of requests. Next, I&amp;rsquo;ll test Roo Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="writing-code-was-never-the-bottleneck"&gt;&lt;a href="https://ordep.dev/posts/writing-code-was-never-the-bottleneck" rel="noopener noreferrer"&gt;Writing code was never the bottleneck&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the claim that large language models (LLMs) have solved the core problem of software engineering. Writing code was never the real bottleneck; the most time-consuming activities have always been code review, knowledge transfer, testing, debugging, and team coordination—activities that demand critical thinking and shared understanding across the team.&lt;/p&gt;
&lt;p&gt;LLMs speed up code generation without speeding up verification to match, so they merely shift the bottleneck rather than removing it: code becomes easier to produce but harder to verify, and the team as a whole does not necessarily move faster. Understanding how the code works, finding bugs, and maintaining quality still take substantial effort, and auto-generated code is sometimes even harder to read and review. When code generation outpaces a team&amp;rsquo;s capacity to communicate, reviewers come under heavy pressure and quality easily suffers. The cost of writing code may drop, but the cost of building shared team understanding of the system does not—and that is the true bottleneck.&lt;/p&gt;
&lt;h2 id="building-tiny-ai-tools"&gt;&lt;a href="https://www.seangoedecke.com/building-tiny-ai-tools/" rel="noopener noreferrer"&gt;Building Tiny AI Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke highlights an overlooked area of AI application alongside agentic coding and mass-market AI products: building tiny, personalized tools to automate repetitive workflows. He distinguishes between &amp;ldquo;executive thought&amp;rdquo; (making strategic decisions) and &amp;ldquo;mechanical thought&amp;rdquo; (reading, analyzing, and summarizing information), noting that the latter can now be handed off to AI.&lt;/p&gt;
&lt;p&gt;He gives two examples: &lt;code&gt;gh-standup&lt;/code&gt;, a GitHub CLI extension that pulls commit history and feeds it through an AI prompt to generate a more useful standup report than manual review, and a GitHub Action that aggregates individual engineers&amp;rsquo; updates into a weekly team summary, saving significant time even though it only serves his own company. Tools like these are too niche to sell commercially yet carry high internal value; the clearest sign is that when they break, coworkers immediately speak up. The author believes that as models continue to improve, this kind of automation will become more widespread, and software engineers are best positioned to build them for their own teams.&lt;/p&gt;
&lt;h2 id="modern-git-commands-and-features-you-should-be-using"&gt;&lt;a href="https://martinheinz.dev/blog/109" rel="noopener noreferrer"&gt;Modern Git Commands and Features You Should Be Using&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Most of us use Git every day yet stick to &lt;code&gt;add&lt;/code&gt;, &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; as if it were still 2005. Martin Heinz introduces more modern commands: &lt;code&gt;git switch&lt;/code&gt; (Git 2.23) replaces &lt;code&gt;git checkout&lt;/code&gt; for switching branches, adding safety checks to prevent data loss and conveniences like &lt;code&gt;git switch -&lt;/code&gt; to jump back to the previous branch; &lt;code&gt;git restore&lt;/code&gt; consolidates file-restoration tasks previously scattered across &lt;code&gt;reset&lt;/code&gt; and &lt;code&gt;checkout&lt;/code&gt; with clearer syntax; &lt;code&gt;git sparse-checkout&lt;/code&gt; (Git 2.25) populates only the needed directories in the working tree of a large monorepo, and when combined with partial clone also reduces downloaded data; &lt;code&gt;git worktree&lt;/code&gt; lets you check out multiple branches simultaneously in separate directories without stashing or cloning again; and &lt;code&gt;git bisect&lt;/code&gt; uses binary search to pinpoint the commit that introduced a bug.&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;span class="lnt"&gt;3
&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-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch other-branch
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch - &lt;span class="c1"&gt;# Switch back to the previous branch&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch remote-branch &lt;span class="c1"&gt;# Switch to a remote branch with automatic tracking&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;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&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-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage and discard working tree changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged --worktree some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Restore a file to a specific commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --source HEAD~2 some-file.py
&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;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git clone --no-checkout https://github.com/example/monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout init --cone
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git checkout main &lt;span class="c1"&gt;# Only checks out files in the root directory&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout &lt;span class="nb"&gt;set&lt;/span&gt; service/common &lt;span class="c1"&gt;# Only pulls the needed directory&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;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree add ../hotfix master &lt;span class="c1"&gt;# Create a new worktree from master&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ../hotfix &lt;span class="c1"&gt;# Work independently&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree list &lt;span class="c1"&gt;# List active worktrees&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-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect start
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect bad HEAD &lt;span class="c1"&gt;# Current commit is broken&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good abc123 &lt;span class="c1"&gt;# Last known good commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Git automatically checks out the midpoint commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good/bad &lt;span class="c1"&gt;# Test and mark the result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect reset &lt;span class="c1"&gt;# Return to the original commit&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;p&gt;The takeaway is that when you run into a Git problem, consult the latest official documentation rather than relying on old StackOverflow answers—Git has evolved considerably, and there is likely already a simpler, safer way to solve your problem.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing, I noticed Kimi K2 consistently responds faster than Qwen 3 Coder whether using Cline or Roo Code, and Roo Code makes more requests than Cline, though my satisfaction with the output is roughly the same. Since OpenRouter&amp;rsquo;s rate limit is based on request count rather than total tokens, I&amp;rsquo;ll probably stick with Cline + Kimi K2 as a fallback whenever Claude Code hits its quota.&lt;/em&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 #43</title><link>https://miti99.com/en/post/2025/08/02/</link><pubDate>Sat, 02 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/02/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I switched the tool to Qwen Code and the model to Qwen 3 Coder, running via the OpenRouter API. Just experimenting a bit to see how it goes.&lt;/del&gt; Enjoy Newsletter #43.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="augmented-coding-beyond-the-vibes"&gt;&lt;a href="https://tidyfirst.substack.com/p/augmented-coding-beyond-the-vibes" rel="noopener noreferrer"&gt;Augmented Coding: Beyond the Vibes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck distinguishes between two ways of working with AI: &amp;ldquo;vibe coding&amp;rdquo; only cares that the system exhibits the right behavior, ignoring code quality and simply feeding errors back to the AI to fix; while &amp;ldquo;augmented coding&amp;rdquo; preserves the values of traditional programming—such as clean code, low complexity, testing, and full coverage—with the only difference being that the programmer types less. To illustrate, he built a B+ Tree library called BPlusTree3 in Rust and Python, which took about four weeks and three rewrites because the first two versions accumulated too much complexity and left the AI stuck. He applied TDD alongside a strict system prompt: separate structural changes from behavioral changes, work on only one unchecked test in &lt;code&gt;plan.md&lt;/code&gt; at a time, and write just enough code for that test to pass. When Rust&amp;rsquo;s memory model caused complexity to spike, he switched to writing in Python and had the agent translate it back into Rust.&lt;/p&gt;
&lt;p&gt;Beck points out three signs that the AI is going off track: looping, adding unrequested features on its own, and &amp;ldquo;cheating&amp;rdquo; by disabling or deleting tests. As a result, the Rust and Python versions achieved competitive performance—slower than standard libraries on a few operations, but faster on range scans; the AI even wrote a C extension for Python with good performance, though its code quality still fell short of his standards. According to Beck, programming with AI remains enjoyable: most setup tedium disappears, and programmers make more consequential decisions per hour of work.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;With the combo above, after writing the first entry, it started looping—sending 3–4 requests to OpenRouter and then getting completely stuck. And that first entry also took a very long time. Next, I&amp;rsquo;ll try Qwen Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Update: it seems Qwen Code doesn&amp;rsquo;t work with Kimi K2—I ran into &lt;code&gt;API Error: Internal Server Error&lt;/code&gt; :v Next up, let&amp;rsquo;s try Cline with Qwen 3 Coder.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-agents-have-crossed-a-chasm"&gt;&lt;a href="https://blog.singleton.io/posts/2025-06-14-coding-agents-cross-a-chasm/" rel="noopener noreferrer"&gt;Coding agents have crossed a chasm&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Singleton argues that in recent months, coding agents have crossed a &amp;ldquo;chasm&amp;rdquo;: from smart autocomplete tools, to real-time pair-programming collaborators, they now resemble a dedicated intern capable of taking on an entire task end-to-end. He uses Claude Code to write small personal tools while barely reading the source code, just running and tweaking them iteratively; a photo-reorganizing script cost only $0.31 in tokens. At work, he hands off simple bugs for Codex to handle end-to-end, and uses GitHub-integrated Claude Code for code reviews, catching issues humans missed. The most impressive example was a race condition in an OAuth integration flow: after 45 minutes of fruitless manual debugging, he asked Claude to draw an ASCII sequence diagram of the entire flow and found the root cause in 10 minutes.&lt;/p&gt;
&lt;p&gt;The author also warns of the &amp;ldquo;mirror effect&amp;rdquo;: the tool amplifies both the user&amp;rsquo;s strengths and weaknesses. On one occasion, the model kept proposing increasingly convoluted solutions and he kept following along, when the actual fix was embarrassingly simple. AI is also prone to band-aiding architectural problems rather than encouraging refactoring, and developers without a solid foundation can be misled by plausible-sounding but wrong suggestions. Even so, he believes the line between &amp;ldquo;AI-assisted&amp;rdquo; and &amp;ldquo;autonomous AI&amp;rdquo; will continue to blur: humans retain ownership of design and key decisions, while AI handles implementation so developers can focus on architecture, user experience, and business logic.&lt;/p&gt;
&lt;h2 id="how-databases-store-your-tables-on-disk"&gt;&lt;a href="https://www.deepintodev.com/blog/how-databases-store-your-tables-on-disk" rel="noopener noreferrer"&gt;How Databases Store Your Tables on Disk&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kaan Pekşen explains how databases actually store tables on disk. The fundamental unit is a page, a fixed-size block of data—for example, 8KB in PostgreSQL and 16KB in MySQL. A database does not read individual rows; it reads an entire page in a single I/O operation, so once a page is in the buffer cache, every row inside it is readily available. Table pages are stored in a heap, where data is placed wherever free space exists, leaving pages in no particular order; searching a heap therefore usually requires a full table scan. An index is a separate structure, typically a B-Tree, containing the indexed column values along with row identifiers, making it possible to pinpoint the exact page to read instead of scanning everything; the index itself is also stored as pages and costs I/O to read.&lt;/p&gt;
&lt;p&gt;With a clustered index, table data is physically sorted according to the index key, so each table can have only one such index; MySQL&amp;rsquo;s InnoDB uses the primary key as the clustered index by default, or a qualifying unique index, falling back to a hidden 6-byte ID if the table has no primary key. Consequently, in InnoDB, secondary indexes point to the primary key value before reaching the data, whereas PostgreSQL points directly to the row&amp;rsquo;s location in the heap via the &lt;code&gt;ctid&lt;/code&gt; column. The article draws several practical lessons: reduce I/O operations through sensible indexing, avoid random UUIDs as primary keys in InnoDB because random inserts degrade performance (auto-incrementing integers are better), and understand that under MVCC, PostgreSQL handles an update as a DELETE plus an INSERT.&lt;/p&gt;
&lt;h2 id="software-engineering-with-llms-in-2025-reality-check"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/software-engineering-with-llms-in-2025" rel="noopener noreferrer"&gt;Software engineering with LLMs in 2025: reality check&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz synthesizes his keynote at the LDX3 conference in London along with interviews across AI tooling companies, Big Tech, AI startups, and veteran engineers to assess the reality of using LLMs in software engineering. On one side are bold CEO claims like &amp;ldquo;within a year, all code will be written by AI&amp;rdquo;; on the other are real-world failures like a tool causing a $733 bug or the GitHub Copilot agent repeatedly stumbling on .NET repositories. At AI tooling companies, the numbers are very high: roughly 90% of Claude Code&amp;rsquo;s codebase is written by Claude Code itself, Windsurf is around 95%, and Cursor is at 40–50%. Google is building AI-integrated internal tools and preparing for a tenfold increase in code volume, while Amazon is becoming an &amp;ldquo;MCP-first&amp;rdquo; company built on thousands of internal APIs. Among startups, incident.io uses Claude Code heavily, whereas a biotech startup found AI tools less useful than traditional tools like ruff or uv.&lt;/p&gt;
&lt;p&gt;Many veteran engineers—such as Armin Ronacher, Simon Willison, Kent Beck, and Martin Fowler—are enthusiastic about agentic tools. Still, open questions remain: why executives are more enthusiastic than developers, why only about half of developers use AI tools weekly, and why median time savings sit at around 4 hours per week, far from the promised 10x productivity boost. The article concludes that agentic tools could represent a major shift akin to moving from assembly to high-level languages, but writing code faster does not automatically translate to shipping software faster unless the surrounding infrastructure and processes evolve alongside it.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, the Cline + Qwen 3 Coder combo works, but it&amp;rsquo;s a bit slow and the output is somewhat rambling—I asked for a summary, yet it wrote very long passages (this might be because I haven&amp;rsquo;t optimized the prompt yet, since I only told it to read &lt;code&gt;CLAUDE.md&lt;/code&gt;). Next, let&amp;rsquo;s try Cline with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="continuous-ai"&gt;&lt;a href="https://www.seangoedecke.com/continuous-ai/" rel="noopener noreferrer"&gt;Continuous AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke defines &amp;ldquo;Continuous AI&amp;rdquo; as any way of automatically integrating AI tools into existing development workflows, much like how tests or type checks run continuously without a developer having to manually trigger them. Instead of only using AI when opening a chat window, AI becomes an ever-present support layer: automated pull request reviews, issue and pull request labeling, periodic summary digests for team coordination, or Copilot-style code completion. The author&amp;rsquo;s view shifted after trying Copilot&amp;rsquo;s pull request review feature: most comments aren&amp;rsquo;t particularly valuable, but roughly once every five to ten times it catches something he missed, and since skimming the comments takes very little effort, it is still worth using.&lt;/p&gt;
&lt;p&gt;For experimentation, the author suggests combining GitHub Models (an inference API with a free tier) with GitHub Actions, bringing AI into existing workflows at very low cost. In his view, rather than chasing fully autonomous &amp;ldquo;AI engineers,&amp;rdquo; a more realistic near-term future is multiple layers of AI systems handling automated checks, organization, and other parts of the software engineering workflow alongside human developers.&lt;/p&gt;
&lt;h2 id="caching-is-an-abstraction-not-an-optimization"&gt;&lt;a href="https://buttondown.com/jaffray/archive/caching-is-an-abstraction-not-an-optimization/" rel="noopener noreferrer"&gt;Caching is an abstraction, not an optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Jaffray argues that caching should be understood first and foremost as an abstraction that simplifies software, rather than merely a performance optimization to avoid hitting slow storage tiers. This perspective creates a clean boundary between storage layers: the rest of the system simply reads and writes data without needing to know whether that data currently resides in a fast tier or a slow tier. The author points to database buffer pools and operating system page caches as examples: they automatically promote frequently accessed data to faster storage without developer intervention, completely hiding the management of storage tiers.&lt;/p&gt;
&lt;p&gt;From this, the author draws two conclusions. First, data access patterns in real-world workloads are too unpredictable, making reliance on heuristics and caching algorithms unavoidable; hand-crafting custom solutions for each case is not a practical option. Second, caching is such a good abstraction that it deserves careful study to operate better in practice: precisely because it succeeds, its importance usually remains invisible until something goes wrong.&lt;/p&gt;
&lt;h2 id="you-should-delete-tests"&gt;&lt;a href="https://andre.arko.net/2025/06/30/you-should-delete-tests/" rel="noopener noreferrer"&gt;You should delete tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;André Arko pushes back against the common industry dogma that tests should never be deleted. In his view, tests have only one purpose: giving humans confidence that they can change code without breaking existing functionality. Any test that no longer serves that purpose should be deleted rather than kept out of principle.&lt;/p&gt;
&lt;p&gt;He outlines several specific cases. Flaky tests do the most harm because they fail randomly, eroding engineers&amp;rsquo; trust even in real failures; the phrase &amp;ldquo;it failed because of that flaky test, it&amp;rsquo;s actually fine&amp;rdquo; gets repeated even when the code is genuinely broken, and spending days debugging such a test often costs more than a future bug would. Over-specified tests—where changing a single line of code requires updating 150 tests—also create false confidence; three meaningful checks are worth more than 150 of those. A test suite so slow that nobody runs it between merges is no different from a fake &amp;ldquo;pass.&amp;rdquo; And tests for old business requirements after a product pivot should be replaced with tests for the new behavior, not patched just to pass. The author isn&amp;rsquo;t against writing tests; he simply wants the test suite to actually do its job of building confidence.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;I found that Cline + Kimi K2 also generates long outputs (likely due to the prompt as mentioned above), but on the bright side, its response time is quite fast, so at least I don&amp;rsquo;t have to wait long. I&amp;rsquo;ll try to improve the prompt in the &amp;ldquo;distant&amp;rdquo; future. Tomorrow I&amp;rsquo;ll test Roo Code + Qwen 3 Coder / Kimi K2 first. See you in tomorrow&amp;rsquo;s post!&lt;/em&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 #41</title><link>https://miti99.com/en/post/2025/07/31/</link><pubDate>Thu, 31 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/31/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #41.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-fastest-way-to-detect-a-vowel-in-a-string"&gt;&lt;a href="https://austinhenley.com/blog/vowels.html" rel="noopener noreferrer"&gt;The Fastest Way to Detect a Vowel in a String&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Austin Henley benchmarks 11 different ways to check whether a string contains a vowel in Python—ranging from a simple &lt;code&gt;for&lt;/code&gt; loop, a C-style loop with chained &lt;code&gt;or&lt;/code&gt; conditions, nested loops, set intersection, a generator expression with &lt;code&gt;any()&lt;/code&gt;, recursion, and &lt;code&gt;filter&lt;/code&gt;/&lt;code&gt;map&lt;/code&gt; with a lambda, all the way to regular expressions and a &amp;ldquo;just for fun&amp;rdquo; prime-number character encoding. The initial results are surprising: on short strings (length 10), a simple loop wins, but from length 100 upward, regex takes the lead while the C-style loop falls far behind. The reason is that Python&amp;rsquo;s regex engine is written in C and uses a bitmap lookup table to match characters instead of interpreting Python bytecode one character at a time.&lt;/p&gt;
&lt;p&gt;The post-publication update is even better: readers pointed out that Python&amp;rsquo;s built-in &lt;code&gt;str.find()&lt;/code&gt; beats regex thanks to CPython&amp;rsquo;s optimized substring search, and simply flipping the loop order—iterating over the vowel string and checking &lt;code&gt;if v in s&lt;/code&gt; against the input—beats both regex and &lt;code&gt;find()&lt;/code&gt;, running roughly 16x faster than regex on long strings. The takeaway is that performance differences in Python mostly come down to the CPython interpreter boundary: whichever approach pushes more of the loop into C wins. In practice, write the readable version unless you are processing millions of strings.&lt;/p&gt;
&lt;h2 id="writing-toy-software-is-a-joy"&gt;&lt;a href="https://blog.jsbarretto.com/post/software-is-joy" rel="noopener noreferrer"&gt;Writing Toy Software Is A Joy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joshua Barretto encourages programmers to build &amp;ldquo;toy software&amp;rdquo;—small, from-scratch projects—to deeply understand how systems work under the hood and rediscover the joy of programming. Starting from Richard Feynman&amp;rsquo;s line, &amp;ldquo;What I cannot create, I do not understand,&amp;rdquo; Barretto argues that building a simplified version of a familiar tool teaches you its core constraints far better than reading theory alone. The guiding rule is the 80:20 principle: spend 20% of the effort to get the 80% of functionality that is actually interesting, implement only what you need, and let the program crash until you are forced to handle an edge case. That mindset turns intimidating systems into approachable weekend projects.&lt;/p&gt;
&lt;p&gt;The post lists 23 project ideas with difficulty ratings (from 3 to 8 out of 10), time estimates, and reference links: easier picks include a regex engine, a CHIP-8 emulator, a hash table, and an interpreter; medium ones cover a physics engine, a text editor, a voxel engine, and an orbital simulator; the hardest are an x86 OS kernel and a compiler for a C-like language. Barretto strongly advises leaving large language models (LLMs) out of these projects, because understanding shouldn&amp;rsquo;t be &amp;ldquo;served on a platter&amp;rdquo;: struggling through the problem yourself is the entire point, especially as everyday software work becomes increasingly commoditized and AI-assisted.&lt;/p&gt;
&lt;h2 id="field-notes-from-shipping-real-code-with-claude"&gt;&lt;a href="https://diwank.space/field-notes-from-shipping-real-code-with-claude" rel="noopener noreferrer"&gt;Field Notes From Shipping Real Code With Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diwank shares battle-tested lessons from shipping production code with Claude. He divides AI-assisted work into three distinct modes: &amp;ldquo;playground&amp;rdquo; mode for weekend hacks and prototypes where Claude writes 80–90% of the code with minimal guardrails; pair-programming mode for codebases under roughly 5,000 lines; and production/monorepo scale with real users, where every step requires deliberate orchestration. The anchor of the workflow is &lt;code&gt;CLAUDE.md&lt;/code&gt;, which acts as the codebase&amp;rsquo;s &amp;ldquo;constitution&amp;rdquo;—recording the reasoning behind architectural decisions, coding standards, test commands, repository conventions, and hard off-limits rules. Complementing it are inline &amp;ldquo;anchor comments&amp;rdquo; like &lt;code&gt;AIDEV-NOTE:&lt;/code&gt;—short, greppable markers that guide both AI agents and human readers.&lt;/p&gt;
&lt;p&gt;His non-negotiable rule is that humans write the tests, because tests encode business requirements and edge cases that AI doesn&amp;rsquo;t truly understand; he illustrates this with an AI-generated test suite that passed green while completely missing a memory leak. AI is strictly forbidden from modifying test files, changing API contracts, touching database migrations, committing secrets, or guessing at domain logic. He also recommends using &lt;code&gt;git worktree&lt;/code&gt; for parallel AI experiments, prefixing AI-assisted commits with &lt;code&gt;[AI]&lt;/code&gt;, and being transparent across the team by agreeing on shared rules upfront—because strong engineering discipline is what separates AI as a force multiplier from AI as a chaos generator.&lt;/p&gt;
&lt;h2 id="why-generative-ai-coding-tools-and-agents-do-not-work-for-me"&gt;&lt;a href="https://blog.miguelgrinberg.com/post/why-generative-ai-coding-tools-and-agents-do-not-work-for-me" rel="noopener noreferrer"&gt;Why Generative AI Coding Tools and Agents Do Not Work For Me&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Miguel Grinberg, author of Flask-SocketIO and several widely used Python libraries, explains why generative AI coding tools and agents don&amp;rsquo;t fit his workflow. His central argument is that they don&amp;rsquo;t actually save him time: because he is personally accountable for every line of code he ships to production, with or without AI, he has to read and fully understand every line before committing. Reviewing AI-generated code takes him just as long as—or longer than—writing it himself, wiping out any time &amp;ldquo;saved&amp;rdquo; during generation.&lt;/p&gt;
&lt;p&gt;Grinberg also pushes back on comparing AI to an intern: a human intern learns and grows more autonomous over time, whereas in his view AI tools have no durable memory across sessions, resetting to square one on every task like an intern with amnesia. He views learning new languages and frameworks firsthand as both a joy and a long-term career investment, not a chore to offload to a machine. And while reviewing open-source community contributions also takes effort, it brings rewards AI never provides: genuine human connection, thoughtful feedback, and fresh ideas that make the project better.&lt;/p&gt;
&lt;h2 id="ai-coding-assistants-aren"&gt;&lt;a href="https://leaddev.com/velocity/ai-coding-assistants-arent-really-making-devs-feel-more-productive" rel="noopener noreferrer"&gt;AI coding assistants aren&amp;rsquo;t really making devs feel more productive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;LeadDev reporter Chantal Kapani examines data from the 2025 Engineering Leadership Report (surveying 617 engineering leaders in March) on perceived productivity gains from AI coding assistants, finding that the impact so far is much more modest than the hype suggests. Only 6% of respondents reported a significant productivity boost, while 39% saw minor improvements in the 1–10% range. Teams primarily use AI for code generation (47%), refactoring (45%), documentation (44%), internal communication (28%), and bug fixing (22%). Those numbers contrast sharply with upbeat vendor and enterprise claims like GitHub&amp;rsquo;s report that 88% of users feel more productive or JPMorgan Chase citing 10–20% efficiency gains, though the studies differ in sample and methodology.&lt;/p&gt;
&lt;p&gt;Industry experts quoted in the piece point to several reasons for the gap: current AI tools focus narrowly on typing code while ignoring deeper workflow bottlenecks; many rollouts are driven top-down by executive excitement rather than validated bottom-up; real delivery latency sits in test runtimes and deployment pipelines rather than keystrokes; and developers are rarely consulted before tools are mandated. The takeaway is to diagnose a team&amp;rsquo;s actual bottlenecks first before assuming AI is the fix.&lt;/p&gt;
&lt;h2 id="how-to-vibe-code-as-a-senior-engineer"&gt;&lt;a href="https://blog.alexmaccaw.com/how-to-vibe-code-as-a-senior-engineer" rel="noopener noreferrer"&gt;How to Vibe Code as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex MacCaw shares how to &amp;ldquo;vibe code&amp;rdquo; effectively as a senior engineer: letting AI models write the bulk of the code while the human steers through crisp prompts and architectural oversight. In his experience, the prerequisites are a rock-solid project scaffold—such as &lt;code&gt;ai-monorepo-scaffold&lt;/code&gt;—with clear examples of migrations, routes, and schemas for the AI to mimic; &lt;code&gt;.cursor/rules&lt;/code&gt; files that instruct the agent to plan first, preserve type safety, and run tests so it behaves like &amp;ldquo;a clean, responsible junior engineer&amp;rdquo;; pulling every relevant file (including type definitions) into context; using Cursor for near-instant lint and typecheck feedback; and picking frontier models like Claude Opus 4 or Gemini 2.5 Pro in &amp;ldquo;thinking&amp;rdquo; mode, prioritizing output quality over token cost.&lt;/p&gt;
&lt;p&gt;On prompting technique, MacCaw advises always asking the model for a plan to approve before it writes code, specifying exact outcomes and target file paths, providing concrete examples, setting explicit constraints (like &amp;ldquo;avoid &lt;code&gt;any&lt;/code&gt;&amp;rdquo;), keeping scope tight, and switching to longer conversational prompts when stuck. He also catalogs AI&amp;rsquo;s recurring blind spots: not knowing what context it is missing, reaching for TypeScript&amp;rsquo;s &lt;code&gt;any&lt;/code&gt; instead of proper types, jumping straight into code without confirming direction, and lacking architectural taste for a project&amp;rsquo;s conventions. MacCaw suggests we may be witnessing &amp;ldquo;the final chapter of human-led programming&amp;rdquo; before AI closes those remaining gaps.&lt;/p&gt;
&lt;h2 id="sql-noir---interactive-sql-game"&gt;&lt;a href="https://www.sqlnoir.com/blog/games-to-learn-sql" rel="noopener noreferrer"&gt;SQL Noir - Interactive SQL Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hristo Bogoev, creator of SQL Noir, rounds up five interactive games that teach SQL through hands-on problem-solving rather than dry textbooks. First is his own SQL Noir, a detective game where you solve crimes by writing SQL queries across six progressively harder cases with realistic schemas, instant feedback, and both free and paid cases. Next is SQL Island, a castaway survival game that works well for beginners despite its dated interface; Northwestern University&amp;rsquo;s SQL Murder Mystery, a single self-contained case that is great for practicing &lt;code&gt;JOIN&lt;/code&gt;s; and SQL Police Department (SQLPD), a paid platform featuring multiple cases, guided hints, and strong storytelling.&lt;/p&gt;
&lt;p&gt;Rounding out the list is SQLZoo, a free interactive tutorial site over 20 years old that systematically covers everything from basic &lt;code&gt;SELECT&lt;/code&gt;s to advanced topics like window functions, albeit without a story wrapper. Together they make a fun practice list for junior developers: newcomers can start with SQL Island or SQL Noir for narrative momentum, then solidify their fundamentals on SQLZoo.&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 #38</title><link>https://miti99.com/en/post/2025/07/28/</link><pubDate>Mon, 28 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/28/</guid><description>&lt;p&gt;&lt;em&gt;Since I still haven&amp;rsquo;t finished my task with &lt;del&gt;Claude Code + Serena MCP&lt;/del&gt; from yesterday&amp;rsquo;s post, today we&amp;rsquo;re back to our boring AI-powered Newsletter series!! Enjoy Newsletter #38 hehe :&amp;gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="9-lessons-from-cursor"&gt;&lt;a href="https://byteatatime.dev/posts/cursor-prompt-analysis/" rel="noopener noreferrer"&gt;9 Lessons From Cursor&amp;rsquo;s System Prompt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteAtATime pointed Cursor at a custom API endpoint (a local ngrok tunnel) to capture the raw requests the editor sends to the model, dissecting the system prompt for Agent mode running on GPT-4.1 and extracting nine prompt-engineering lessons. First, Cursor defines the persona sharply: the AI is a pair-programming assistant operating inside Cursor as an autonomous agent. Roughly 1,250 tokens of instructions are organized into XML-tagged blocks like &lt;code&gt;&amp;lt;communication&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;tool_calling&amp;gt;&lt;/code&gt;, and &lt;code&gt;&amp;lt;making_code_changes&amp;gt;&lt;/code&gt; so the model doesn&amp;rsquo;t lose track of directives buried mid-prompt. The prompt repeatedly pushes autonomy: keep going until the user&amp;rsquo;s request is completely resolved, look up information with tools rather than asking the user, and plan before acting. It also tells the model never to mention internal tool names to the user, alongside practical guardrails like not generating long hashes and not attempting to fix linter errors more than three times on the same file.&lt;/p&gt;
&lt;p&gt;Most interestingly, Cursor sends two separate user-role messages: the first carries the user&amp;rsquo;s custom rules, and the second holds the actual query wrapped in rich context including web search results, file contents, and IDE state. As the author sums it up, context is &amp;ldquo;king, queen, and the entire royal court&amp;rdquo;: the more directly relevant information you pack into the prompt, the better the model performs. The final two lessons come from tool design: the file-reading tool returns only 200 to 250 lines per call to protect the context window, while terminal command outputs append stateful metadata like the current working directory so subsequent tool calls stay accurate.&lt;/p&gt;
&lt;h2 id="my-ai-skeptic-friends-are-all-nuts"&gt;&lt;a href="https://fly.io/blog/youre-all-nuts/" rel="noopener noreferrer"&gt;My AI Skeptic Friends Are All Nuts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas Ptacek (Fly.io) writes a deliberately provocative piece aimed at his AI-skeptic friends: even if LLM progress froze today, it would still be the second most important shift of his career. In his view, most dismissals are anchored in an outdated workflow—asking ChatGPT a question and pasting the snippet into an editor—whereas serious users now work with agents that read project files directly, run Unix tools, interact with Git, run linters, compile, execute tests, and iterate on the output. Because of that feedback loop, he argues, &amp;ldquo;hallucination&amp;rdquo; is largely a solved problem in practice: when an LLM invents a nonexistent function, the agent sees the compiler error and fixes it on the next turn. LLMs can handle the bulk of tedious code, freeing developers to spend their energy on the parts that truly matter.&lt;/p&gt;
&lt;p&gt;Ptacek addresses the remaining objections one by one. You are still responsible for whatever you merge to &lt;code&gt;main&lt;/code&gt;, so review AI-generated code just as you would a colleague&amp;rsquo;s. &amp;ldquo;Mediocre&amp;rdquo; code isn&amp;rsquo;t a dealbreaker because most code doesn&amp;rsquo;t need to be art, and LLMs actually raise the quality floor. LLMs struggling with Rust is mostly a tooling problem today, whereas Go pairs remarkably well with agents. On the craftsmanship argument, he reminds readers that professional developers are paid to solve real problems for people with code, not to act as artisanal woodworkers in their day jobs. He readily concedes that LLMs may shrink software job headcount, and ends by noting that his skeptic friends are sharp engineers—once they actually try coding agents, they&amp;rsquo;ll be even more effective with them than everyone else.&lt;/p&gt;
&lt;h2 id="claude-4-best-practices"&gt;&lt;a href="https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices" rel="noopener noreferrer"&gt;Claude 4 Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official prompt-engineering guide for Claude models, originally written for Claude 4 and since updated for newer generations. The foundational rule is to write clear, explicit instructions: treat Claude like a brilliant new hire who has zero context on your team&amp;rsquo;s norms. If you want &amp;ldquo;above and beyond&amp;rdquo; output, ask for it explicitly—for example, instead of just saying &amp;ldquo;Create an analytics dashboard,&amp;rdquo; add &amp;ldquo;Include as many relevant features and interactions as possible.&amp;rdquo; Explaining the &lt;em&gt;why&lt;/em&gt; behind a constraint helps Claude generalize toward your real goal; wrap few-shot examples in &lt;code&gt;&amp;lt;example&amp;gt;&lt;/code&gt; tags, and separate instructions, context, and input data with XML tags. For long documents, place the reference material at the top of the prompt and the question at the very end, asking Claude to quote relevant passages before answering.&lt;/p&gt;
&lt;p&gt;To control formatting, tell Claude what to do rather than what &lt;em&gt;not&lt;/em&gt; to do—such as &amp;ldquo;write in smooth, flowing prose paragraphs&amp;rdquo; instead of &amp;ldquo;do not use markdown&amp;rdquo;—and match your prompt&amp;rsquo;s formatting style to the output style you want. The guide also covers leveraging extended thinking to reflect on results after tool calls, encouraging parallel tool execution for independent operations, and tracking state across long-running tasks. For coding specifically, instruct Claude to write general-purpose solutions that work for all valid inputs rather than hardcoding values to pass visible tests, since tests are meant to verify correctness rather than define the implementation.&lt;/p&gt;
&lt;h2 id="stop-over-thinking-ai-subscriptions"&gt;&lt;a href="https://steipete.me/posts/2025/stop-overthinking-ai-subscriptions" rel="noopener noreferrer"&gt;Stop Over-thinking AI Subscriptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Steinberger, tired of constantly being asked how much he spends on AI, runs the numbers to show that AI subscriptions are a bargain compared to the time they save. At the time of writing (early June 2025), he calls the $200/month Claude Max 20x plan the best deal in tech: roughly 900 messages per 5-hour window, which translates to virtually unlimited Claude Code usage. Cursor Pro at $20/month includes 500 fast requests and charges $0.04 per extra request, meaning a three-hour live tutorial with over 200 requests cost him only about $8. His biggest variable expense is OpenAI&amp;rsquo;s o3 ($10 per million input tokens, $40 per million output tokens), which makes up roughly half of his total AI bill; developers on a tighter budget can route o3 through a standard ChatGPT subscription using Repo Prompt, or join Anthropic&amp;rsquo;s developer partner program for 30% off API rates. He even built a menu-bar app called Vibe Meter to track spend in real time.&lt;/p&gt;
&lt;p&gt;Addressing fears of future price hikes, Steinberger points out that per-token inference costs have dropped roughly 1,000x over two years and competition continues to drive prices down. For contractors, the math is dead simple: at an $800 day rate, saving a single afternoon a month is worth $200, meaning Claude Max pays for itself in 5 hours and Cursor in 45 minutes. His takeaway: time is the only resource you cannot replenish, and Claude Max was the cheapest way to &amp;ldquo;mint&amp;rdquo; extra working hours.&lt;/p&gt;
&lt;h2 id="tests-should-not-contain-logic"&gt;&lt;del&gt;&lt;a href="https://blog.snork.dev/posts/tests-should-not-contain-logic.html" rel="noopener noreferrer"&gt;Tests Should Not Contain Logic&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This short post makes a case for keeping logic—especially conditionals and loops—out of unit tests so that when a test fails, you can immediately rule out a bug in the test itself. The author illustrates this with a buggy FizzBuzz implementation: because it checks &lt;code&gt;n % 3&lt;/code&gt; before &lt;code&gt;n % 15&lt;/code&gt;, calling &lt;code&gt;fizzbuzz(15)&lt;/code&gt; returns &lt;code&gt;&amp;quot;fizz&amp;quot;&lt;/code&gt; instead of &lt;code&gt;&amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;. If a developer tries to avoid repetitive assertions by writing a loop that computes the expected value using the exact same &lt;code&gt;if/elif&lt;/code&gt; chain, the test duplicates the production bug and passes anyway. By contrast, &amp;ldquo;obvious&amp;rdquo; flat assertions with literal expected values, like &lt;code&gt;assert fizzbuzz(15) == &amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;, catch the bug immediately.&lt;/p&gt;
&lt;p&gt;To reduce repetition without sneaking logic back into tests, the author recommends parameterized (table-driven) tests: declare a list of explicit &lt;code&gt;(input, expected)&lt;/code&gt; pairs—such as &lt;code&gt;(1, &amp;quot;1&amp;quot;)&lt;/code&gt;, &lt;code&gt;(3, &amp;quot;fizz&amp;quot;)&lt;/code&gt;, &lt;code&gt;(5, &amp;quot;buzz&amp;quot;)&lt;/code&gt;, and &lt;code&gt;(15, &amp;quot;fizzbuzz&amp;quot;)&lt;/code&gt; with &lt;code&gt;@pytest.mark.parametrize&lt;/code&gt; in pytest. That keeps tests concise and readable while verifying each case independently against a concrete literal.&lt;/p&gt;
&lt;h2 id="do-you-really-know-java"&gt;&lt;a href="https://blog.jetbrains.com/idea/2025/05/do-you-really-know-java/" rel="noopener noreferrer"&gt;Do You Really Know Java?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marking Java&amp;rsquo;s 30th anniversary, this JetBrains retrospective looks back at the language&amp;rsquo;s journey. In 1991, James Gosling&amp;rsquo;s team at Sun Microsystems kicked off the Green Project to build software for consumer electronics, needing a lightweight, safe language that could run across any hardware. Originally named Oak after the tree outside Gosling&amp;rsquo;s office window, the language was renamed Java after a trademark clash—likely inspired by Java coffee. Java debuted publicly in 1995 right as the web exploded. Its standout features for the era included &amp;ldquo;write once, run anywhere&amp;rdquo; portability via the JVM, automatic garbage collection, built-in multithreading (now joined by virtual threads from Project Loom), and a sandbox security model that treated untrusted code as a potential threat.&lt;/p&gt;
&lt;p&gt;The post also traces IntelliJ IDEA&amp;rsquo;s arrival in 2001, bringing context-aware code completion, reliable automated refactorings, and real-time static analysis. In the AI era, Java 24 ships over 20 features—including the Vector API to tap specialized CPU instructions for compute-heavy workloads—alongside Projects Panama, Amber, and Valhalla and ecosystem frameworks like LangChain4j and Spring AI. As the article puts it, Java doesn&amp;rsquo;t chase hype; it quietly gets stronger where it counts. Fun closing trivia: Java&amp;rsquo;s mascot Duke was designed by Joe Palrang, who later worked on animated films like &lt;em&gt;Shrek&lt;/em&gt; and &lt;em&gt;Madagascar&lt;/em&gt;.&lt;/p&gt;
&lt;h2 id="machine-code-isn"&gt;&lt;a href="https://jimmyhmiller.com/machine-code-isnt-scary" rel="noopener noreferrer"&gt;Machine Code Isn&amp;rsquo;t Scary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller, who started out writing ActionScript in Flash, shares how he got over his fear of working close to the metal. Once he actually dug in, he realized that if you can make sure a JSON payload conforms to a JSON schema, you can write machine code. Machine code isn&amp;rsquo;t a single universal format—it depends on the processor&amp;rsquo;s instruction set architecture (x86-64 on most PCs, ARM on modern Macs, Raspberry Pis, and phones)—but it revolves around just three concepts: instructions, registers, and memory. On AArch64, every instruction is a 32-bit integer; an add-immediate instruction, for instance, is just a packed bit layout combining a 64-bit flag, a 12-bit immediate value, a source register, and a destination register at fixed bit offsets. Assembly like &lt;code&gt;add x1, x0, #0x2a&lt;/code&gt; is simply a human-readable shorthand for that integer, while &lt;code&gt;str&lt;/code&gt; writes a value to memory much like assigning into a giant array.&lt;/p&gt;
&lt;p&gt;x86-64 is messier because instructions have variable lengths and carry decades of &amp;ldquo;historical baggage,&amp;rdquo; yet the building blocks are the same: a REX prefix for 64-bit operations, a ModR/M byte specifying register or memory addressing, and an opcode. Miller puts those bytes together by hand to encode an instruction that loads the number 42 into the &lt;code&gt;RBX&lt;/code&gt; register. He notes there is still plenty more to learn—status flags, calling conventions, the stack—but getting a minimal program running from raw bytes dissolved the mystique and filled in foundational gaps he had previously papered over with other people&amp;rsquo;s libraries.&lt;/p&gt;
&lt;h2 id="the-art-of-sql-query-optimization"&gt;&lt;a href="https://jnidzwetzki.github.io/2025/06/03/art-of-query-optimization.html" rel="noopener noreferrer"&gt;The Art of SQL Query Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SQL is declarative: you state &lt;em&gt;what&lt;/em&gt; result you want, and the database engine figures out &lt;em&gt;how&lt;/em&gt; to compute it. The query optimizer enumerates candidate execution plans, estimates their cost, and picks the cheapest one—for example, when a query returns most of a table, a sequential full-table scan is often faster than chasing index pointers. To visualize where PostgreSQL switches plans, Jan Nidzwetzki built Plan Explorer, an open-source tool inspired by the Picasso optimizer visualizer: it runs a parameterized query across a 2D grid of selectivity values and plots the chosen execution plan, estimated cost, actual runtime, estimated row count, and actual row count. It can run entirely in the browser via PGlite (PostgreSQL compiled to WebAssembly) or in server mode against a real PostgreSQL instance using &lt;code&gt;EXPLAIN (ANALYZE)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;On a self-join over an indexed 100,000-row table, Plan Explorer reveals PostgreSQL switching between five distinct execution plans depending on the filter bounds. One neat detail: even when the query is written with a &lt;code&gt;LEFT JOIN&lt;/code&gt;, PostgreSQL executes an &lt;code&gt;INNER JOIN&lt;/code&gt; because a filter on the right-hand table eliminates any &lt;code&gt;NULL&lt;/code&gt;-padded rows the left join would have produced. The visualizations also expose a cardinality-estimation bug: PostgreSQL assumes two filter predicates are correlated when they are actually independent, causing estimated row counts to diverge sharply from reality—a case where extended statistics can help. Beyond the striking visual patterns, Plan Explorer is a practical workbench for anyone tuning or developing custom cost models in PostgreSQL.&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 #37</title><link>https://miti99.com/en/post/2025/07/26/</link><pubDate>Sat, 26 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #37.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="i-think-it"&gt;&lt;a href="https://maych.in/blog/its-time-to-give-nix-a-chance/" rel="noopener noreferrer"&gt;I Think It&amp;rsquo;s Time to Give Nix a Chance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chinmay D. Pai makes the case that Nix deserves a closer look from everyday developers. Unlike traditional package managers that install everything into shared global directories, Nix stores each package inside an immutable &lt;code&gt;/nix/store&lt;/code&gt; path prefixed with a cryptographic hash of all its build inputs. That allows multiple versions of the same software to coexist without conflict, each carrying its own complete dependency tree. Nix flakes pin dependencies so environments can be reproduced reliably across machines, even if they don&amp;rsquo;t guarantee bit-for-bit identical builds in every case. You can also try out tools without installing them permanently via &lt;code&gt;nix shell&lt;/code&gt; or &lt;code&gt;nix run&lt;/code&gt;, while the immutable store and non-standard filesystem layout neutralize several common Linux attack vectors.&lt;/p&gt;
&lt;p&gt;Pai is equally candid about the downsides: learning a bespoke functional language, deciphering cryptic error messages, understanding Nix&amp;rsquo;s evaluation model to debug issues, wrestling with software that hardcodes standard Linux paths, high disk usage, and fragmented documentation. To get started without drowning, he recommends installing via the Determinate Systems Installer, experimenting with &lt;code&gt;nix shell&lt;/code&gt;, and then setting up a simple project dev shell. Nix pays off most for teams plagued by &amp;ldquo;works on my machine&amp;rdquo; drift, painful onboarding, cross-platform builds, or strict compliance requirements—while small projects with stable dependencies probably don&amp;rsquo;t need it yet.&lt;/p&gt;
&lt;h2 id="you-can-choose-tools-that-make-you-happy"&gt;&lt;a href="https://borretti.me/article/you-can-choose-tools-that-make-you-happy" rel="noopener noreferrer"&gt;You Can Choose Tools That Make You Happy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fernando Borretti argues that programmers&amp;rsquo; technology choices are driven largely by emotion rather than the pure engineering rationality we claim. People pick tools that match an aesthetic and a desired self-image: using Emacs because it feels intellectually elite, or running NetBSD because it fits a cyberpunk persona. Afterward, we construct technical rationalizations to disguise the real motive—downplaying glaring flaws in niche tools (&amp;ldquo;sure, I had to write my own HTTP server&amp;rdquo;), inventing dubious advantages, or lobbing vague criticisms at mainstream options like &amp;ldquo;Docker is too complex&amp;rdquo; or &amp;ldquo;C++ builds character, whereas Rust makes you soft.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Borretti has no problem with emotional tool choices as long as you don&amp;rsquo;t lie to yourself or others. If you pick something for its aesthetic or identity, lean into it honestly and intentionally; just don&amp;rsquo;t claim SNOBOL has a bright commercial future, or tell your manager the decision came from a sober cost-benefit analysis. The core message: you are allowed to choose tools that make you happy—just be honest about why. He also cautions that passion still needs a reality check, because extreme choices divorced from reason can sink years into dead-end paths.&lt;/p&gt;
&lt;h2 id="the-copilot-delusion"&gt;&lt;del&gt;&lt;a href="https://deplet.ing/the-copilot-delusion/" rel="noopener noreferrer"&gt;The Copilot Delusion&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post delivers a sharp critique of AI coding assistants like GitHub Copilot and their negative impact on software development. The author argues that these tools generate code without any real understanding of system architecture or deep technical trade-offs.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The core concern is that relying on AI erodes developers&amp;rsquo; critical thinking and ability to learn. When we &amp;ldquo;outsource our thinking to AI,&amp;rdquo; we also &amp;ldquo;outsource our learning&amp;rdquo; to it. These tools lack intuition for hardware performance, memory management, and low-level optimization—key ingredients of high-quality software engineering.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author worries about the cultural shift across the industry, warning it could produce a generation of developers who prioritize fast output over quality, threatening the &amp;ldquo;hacker spirit&amp;rdquo; and deep technical curiosity. The risk is a wave of developers who think they are skilled simply because their bot got CI to pass, while lacking foundational understanding.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Main concerns:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- AI generates code without understanding system architecture&lt;/del&gt;
&lt;del&gt;- Erosion of developers&amp;rsquo; critical thinking skills&lt;/del&gt;
&lt;del&gt;- Lack of intuition around performance and optimization&lt;/del&gt;
&lt;del&gt;- Risk of creating a generation of developers who are only &amp;ldquo;good on paper&amp;rdquo;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="why-cline-doesn"&gt;&lt;a href="https://cline.bot/blog/why-cline-doesnt-index-your-codebase-and-why-thats-a-good-thing" rel="noopener noreferrer"&gt;Why Cline Doesn&amp;rsquo;t Index Your Codebase (And Why That&amp;rsquo;s a Good Thing)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this May 2025 post, the Cline team explains why they deliberately avoid vector-indexing your codebase and why direct exploration fits their agent better. First, code doesn&amp;rsquo;t work in isolated fragments: chopping it into small chunks breaks interconnected logic, like trying to understand a symphony from random ten-second clips, especially since source code lacks the clean paragraph boundaries of prose. Second, indexes go stale fast as code is refactored and updated; an outdated snapshot can lead an AI to suggest functions that no longer exist or miss recent architectural shifts. Third, generating vector embeddings creates a secondary copy of your intellectual property, bringing extra storage and security risk.&lt;/p&gt;
&lt;p&gt;Instead, Cline navigates a repository the way an experienced engineer does: systematically following imports and call chains. When modifying a payment handler, for instance, Cline traces imports to locate custom error utilities, inspects sibling functions to pick up local conventions, and checks call sites—building contextual understanding rather than doing fuzzy pattern matching. That workflow is now practical thanks to the huge context windows of modern frontier models, shifting the bottleneck from raw retrieval volume to context quality: prioritizing comprehension over retrieval.&lt;/p&gt;
&lt;h2 id="the-perfect-commit"&gt;&lt;a href="https://simonwillison.net/2022/Oct/29/the-perfect-commit/" rel="noopener noreferrer"&gt;The Perfect Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he organizes his work around the idea of the &amp;ldquo;perfect commit,&amp;rdquo; treating each commit as a carefully packaged unit of work rather than a rough save point. A perfect commit bundles four things: an implementation focused on a single change, tests proving it works, updated documentation, and a link to an issue thread with the surrounding context. In his view, tests boost long-term velocity by letting you change code confidently without regressions, so every project should start with at least one passing test. Documentation—whether for a Python module, a web service, or a CLI tool—belongs right inside the repository so it stays in sync with the code, is versioned alongside it, and gets reviewed in the same diff.&lt;/p&gt;
&lt;p&gt;Rather than writing long commit messages, Willison puts rich context into GitHub issues, which are easier to search, support pasted screenshots, and can be updated later. He acknowledges this goes against traditional Git orthodoxy, but finds it much more effective in practice. Not every commit needs all four elements: tiny bug fixes or doc typo corrections can skip the ceremony. For messy exploratory work, use a separate branch with rough commits and squash-merge a single clean commit into &lt;code&gt;main&lt;/code&gt;. To make the habit effortless, he uses cookiecutter templates that pre-configure test harnesses and GitHub Actions from day one, as seen across open-source projects like Datasette and &lt;code&gt;sqlite-utils&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-software-engineering-kanagawa-moment"&gt;&lt;a href="https://pashabitz.substack.com/p/the-software-engineering-kawagara" rel="noopener noreferrer"&gt;The Software Engineering Kanagawa Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pasha uses Hokusai&amp;rsquo;s woodblock print &amp;ldquo;The Great Wave off Kanagawa&amp;rdquo; as a metaphor for the wave of AI automation reshaping software engineering. In his view, programming is uniquely exposed to automation because abundant training data exists, outputs can be verified objectively, and the field faces none of the regulatory barriers that protect professions like medicine or law. Coding agents have already moved well past autocomplete, turning ticket descriptions into complete pull requests, while junior developer hiring has noticeably cooled. Well-bounded, self-contained tasks like refactoring and test writing are being automated first.&lt;/p&gt;
&lt;p&gt;What remains for humans is understanding business needs, shaping product design, setting up technical scaffolding, and defining coding conventions—though the author admits even that boundary is fragile as language models keep improving. His advice for engineers at every level is to adopt coding agents actively, audit workflows for automation opportunities, and sharpen product and business judgment; junior developers in particular should practice shipping end-to-end products, learn deployment infrastructure, and study how real production systems are built rather than just following tutorials. His conclusion is blunt: the wave cannot be stopped, and much like agricultural mechanization shifted labor out of farming, it could displace millions of coding jobs.&lt;/p&gt;
&lt;h2 id="websockets-guarantee-order---so-why-are-my-messages-scrambled"&gt;&lt;a href="https://www.sitongpeng.com/writing/websockets-guarantee-order-so-why-are-my-messages-scrambled" rel="noopener noreferrer"&gt;WebSockets guarantee order - so why are my messages scrambled?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sitong Peng recounts an interesting debugging mystery: WebSocket messages were showing up out of order in her logs, even though WebSockets run over TCP, which guarantees in-order delivery. The culprit wasn&amp;rsquo;t the network protocol, but the application layer. The message event handler called &lt;code&gt;await blob.arrayBuffer()&lt;/code&gt;, suspending execution while each message payload was processed; because processing took anywhere from 1 to 5 seconds per message, a smaller message that arrived later could finish before an earlier, slower one. TCP delivered the frames in exact order—the async handler scrambled them afterward.&lt;/p&gt;
&lt;p&gt;Peng walks through two fixes. The first buffers incoming messages in a queue and processes them in batches of five with &lt;code&gt;Promise.all&lt;/code&gt;, preserving order across results while still allowing parallelism within each batch. The second uses an async generator to process messages strictly one at a time—slower since there is no concurrency, but guaranteeing total ordering when application logic requires it. The broader lesson is how tricky it is to debug across multiple abstraction layers: even when the transport layer guarantees reliability and ordering, careless concurrency in application code can undo it, so you have to separate what each layer actually promises.&lt;/p&gt;
&lt;h2 id="why-agents-are-bad-pair-programmers"&gt;&lt;a href="https://justin.searls.co/posts/why-agents-are-bad-pair-programmers/" rel="noopener noreferrer"&gt;Why agents are bad pair programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Searls argues that AI coding agents make terrible pair programmers because they &amp;ldquo;write code faster than humans can think.&amp;rdquo; That speed breaks the collaborative loop: the human partner can&amp;rsquo;t keep up, tunes out, and loses track of how the system works. It feels like pairing with someone who grabs the keyboard and types in silence at superhuman speed. When the agent inevitably hits a wall, the human lacks the mental context from earlier decisions needed to bail it out; worse, the agent may have solved the wrong problem entirely, leaving behind a pile of accidental complexity to clean up.&lt;/p&gt;
&lt;p&gt;Searls suggests two paths forward. First, move agents into an asynchronous workflow: hand them self-contained tasks and review the output via pull requests, like GitHub&amp;rsquo;s Coding Agent. Second, slow things down when working synchronously by using &amp;ldquo;Edit&amp;rdquo; or &amp;ldquo;Ask&amp;rdquo; modes instead of fully autonomous &amp;ldquo;Agent&amp;rdquo; mode; ping-pong pairing in Edit mode, where you review and approve each step, strikes the best balance. He also urges toolmakers to add adjustable generation speed, pause-and-ask checkpoints, UIs that reflect workflow state like GitHub integration and to-do lists, less overconfident agent personas that check in more often, and voice chat. Those changes would turn agents into genuine collaborators rather than lone sprinters.&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 #34</title><link>https://miti99.com/en/post/2025/07/23/</link><pubDate>Wed, 23 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #34.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-tdd-doesn"&gt;&lt;a href="https://tidyfirst.substack.com/p/why-tdd-doesnt-lead-to-dumb-code" rel="noopener noreferrer"&gt;Why TDD Doesn&amp;rsquo;t Lead to Dumb Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck pushes back against a common critique: that test-driven development (TDD) leads to &amp;ldquo;dumb&amp;rdquo; code because programmers write only the bare minimum to pass each test and never generalize. In his view, the design quality of TDD code is only as good as the design decisions its author makes—no different from code written without TDD. He illustrates this with a factorial function: start with &lt;code&gt;assert factorial(1) == 1&lt;/code&gt; and return &lt;code&gt;1&lt;/code&gt;, then add &lt;code&gt;assert factorial(2) == 2&lt;/code&gt; and temporarily return &lt;code&gt;2&lt;/code&gt;. Rather than piling on &lt;code&gt;if&lt;/code&gt; statements forever, the programmer notices the underlying structure: &lt;code&gt;2&lt;/code&gt; is really &lt;code&gt;2 * 1&lt;/code&gt;, where &lt;code&gt;2&lt;/code&gt; is the parameter &lt;code&gt;n&lt;/code&gt; and &lt;code&gt;1&lt;/code&gt; is the result of a recursive call, arriving at the general &lt;code&gt;n * factorial(n - 1)&lt;/code&gt; in tiny steps.&lt;/p&gt;
&lt;p&gt;The real difficulties lie elsewhere: sometimes you don&amp;rsquo;t yet have enough tests to constrain the code to only the right behavior, and sometimes you don&amp;rsquo;t yet see how to generalize and leave a few special cases in place for years—which is still fine as long as the code handles the cases that matter. What never happens is endless copy-pasting. Finally, Beck points out that a naive implementation is tightly coupled to the test suite, requiring code edits every time an assertion is added, whereas generalizing decouples them so you can add tests without changing code and vice versa.&lt;/p&gt;
&lt;h2 id="how-discord-indexes-trillions-of-messages"&gt;&lt;a href="https://discord.com/blog/how-discord-indexes-trillions-of-messages" rel="noopener noreferrer"&gt;How Discord Indexes Trillions of Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord recounts how it re-architected its message search system—originally built on Elasticsearch in 2017—to keep up with trillions of messages. The old setup was showing serious cracks: Redis-backed indexing queues dropped messages when backlogged, bulk indexing wasn&amp;rsquo;t fault-tolerant when an Elasticsearch index or node had trouble, large clusters were expensive to operate and painful to upgrade or rolling-restart, and indexes for massive servers (guilds) grew unwieldy. Their new architecture runs Elasticsearch on Kubernetes via the Elastic Operator, splits storage into many smaller clusters grouped into &amp;ldquo;cells,&amp;rdquo; replaces Redis queues with Google PubSub for durability and replayability, and introduces a Rust router built on Tokio to batch messages by target cluster and index before bulk indexing.&lt;/p&gt;
&lt;p&gt;The cell architecture also unlocked new product capabilities: direct messages (DMs) are sharded by &lt;code&gt;user_id&lt;/code&gt; inside a dedicated cell, enabling cross-DM search for a user. For &amp;ldquo;Big Freaking Guilds&amp;rdquo; that hit Lucene&amp;rsquo;s ~2-billion-document limit, Discord reindexes their messages into indexes with more primary shards inside a dedicated cell. The results: indexing throughput doubled, median query latency dropped from 500 ms to under 100 ms (p99 from 1 second to under 500 ms), the team now runs 40 clusters hosting thousands of indexes, and cluster upgrades happen automatically without user-visible impact.&lt;/p&gt;
&lt;h2 id="data-oriented-programming-dop-in-java"&gt;&lt;a href="https://nejckorasa.github.io/posts/data-oriented-programming-in-java/" rel="noopener noreferrer"&gt;Data Oriented Programming (DOP) in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Data-Oriented Programming (DOP) flips traditional object-oriented habits on their head: instead of bundling state and behavior together inside a class, you model data with simple passive structures and put logic in standalone functions that operate on that data. The post outlines four principles: model data immutably and transparently, model only the exact data needed, make illegal states unrepresentable, and separate operations from data. Modern Java supports this style cleanly through three features: &lt;code&gt;record&lt;/code&gt;s provide compact data carriers with &lt;code&gt;final&lt;/code&gt; fields (though they don&amp;rsquo;t automatically make referenced objects deeply immutable), &lt;code&gt;sealed&lt;/code&gt; classes restrict subtypes so the compiler knows every case, and pattern-matching &lt;code&gt;switch&lt;/code&gt; expressions enforce exhaustiveness, shifting bugs from runtime to compile time.&lt;/p&gt;
&lt;p&gt;In a &lt;code&gt;Shape&lt;/code&gt; example with &lt;code&gt;Circle&lt;/code&gt;, &lt;code&gt;Rectangle&lt;/code&gt;, and &lt;code&gt;Triangle&lt;/code&gt;, a &lt;code&gt;getCenter&lt;/code&gt; function written as a single &lt;code&gt;switch&lt;/code&gt; expression replaces adding methods across every subclass, removing the need for the Visitor pattern in this case. When a new subtype like &lt;code&gt;Pentagon&lt;/code&gt; is added, the compiler flags every &lt;code&gt;switch&lt;/code&gt; missing that branch—which is why the author advises avoiding &lt;code&gt;default&lt;/code&gt; branches that silence exhaustiveness checks. DOP also fits explicit result handling, such as a &lt;code&gt;Result&lt;/code&gt; type with &lt;code&gt;Ok&lt;/code&gt; and &lt;code&gt;Error&lt;/code&gt; variants that forces callers to handle both outcomes. Overall benefits include code that is easier to read, maintain, test, and refactor safely with lower coupling.&lt;/p&gt;
&lt;h2 id="why-performance-optimization-is-hard-work"&gt;&lt;a href="https://purplesyringa.moe/blog/why-performance-optimization-is-hard-work/" rel="noopener noreferrer"&gt;Why performance optimization is hard work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that performance optimization is hard not because engineers lack skill or knowledge, but because it is inherently exhaustive work that requires testing a huge number of possibilities. First is combinatorics: some optimizations only pay off when combined, others slow each other down, and ruling out &amp;ldquo;obviously bad&amp;rdquo; ideas upfront is mostly guesswork because a simple algorithm can win via vectorization while clever code loses to branch mispredictions. Second is continuity: algorithms with crossover thresholds, like hybrid sorts or FFTs, require tuning parameters empirically and re-measuring after every change, making an automated benchmark harness invaluable. Third is incompatibility: hardware constraints like two lookup tables that cannot fit in cache together or register pressure force hard trade-offs.&lt;/p&gt;
&lt;p&gt;The post also pushes back on the myth that &amp;ldquo;the compiler is smarter than you&amp;rdquo;: compilers don&amp;rsquo;t reason at the level of your domain abstractions and often allocate registers poorly, so you still have to inspect assembly and profile with tools like &lt;code&gt;perf&lt;/code&gt;. Documentation is another hurdle: x86 has detailed optimization manuals, whereas Apple Silicon has almost none, turning optimization into reverse engineering. In short, optimization means exploring dozens of variants, working around imperfect tooling, and reconciling conflicting wins—yet small improvements compound and are still worth the effort because they save real users&amp;rsquo; time.&lt;/p&gt;
&lt;h2 id="good-vs-great-animations"&gt;&lt;a href="https://emilkowal.ski/ui/good-vs-great-animations" rel="noopener noreferrer"&gt;Good vs Great Animations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski shares practical tips for taking UI animations from good to great. First, give animations a clear origin: a dropdown menu should expand from the button that triggered it by setting &lt;code&gt;transform-origin&lt;/code&gt;, and libraries like Radix expose CSS variables you can plug right in. Easing is the single most impactful lever; for an element already on screen that moves to a new position, &lt;code&gt;ease-in-out&lt;/code&gt; mimics natural acceleration and deceleration like a car, while &lt;code&gt;ease-out&lt;/code&gt; should be the default almost everywhere else. Built-in CSS easing curves are often too mild, so Kowalski nearly always reaches for custom curves and recommends easing.dev and easings.co.&lt;/p&gt;
&lt;p&gt;For cursor-driven interactions, tying values directly to mouse coordinates feels robotic; Motion&amp;rsquo;s &lt;code&gt;useSpring&lt;/code&gt; hook interpolates changes with spring physics so movement feels natural, though he advises saving it for decorative motion rather than functional charts like those in a banking app. Knowing your tools matters too: &lt;code&gt;clip-path&lt;/code&gt; makes tab-bar label colors transition cleanly in sync with the active indicator, while 3D transforms open up expressive effects. In Kowalski&amp;rsquo;s view, when baseline software quality is high everywhere, thoughtful motion is one of the clearest ways for a product to stand out.&lt;/p&gt;
&lt;h2 id="senior-engineers-should-make-side-bets"&gt;&lt;a href="https://www.seangoedecke.com/side-bets/" rel="noopener noreferrer"&gt;Senior engineers should make side bets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that junior engineers should stick closely to assigned work, because their tasks need experienced oversight and the fastest path to promotion is executing their core assignments well. Senior engineers, by contrast, shouldn&amp;rsquo;t just work down a ticket queue—they should spend 10–20% of their time on &amp;ldquo;side bets&amp;rdquo;: projects they believe are valuable to the company that nobody has asked for yet, such as a new feature, a performance optimization, or a developer-velocity improvement, provided the payoff is concrete. Side bets carry real risk: at worst you waste time and look to management like you&amp;rsquo;re working on the wrong things, and most bets will fail—in which case you quietly drop them and move on.&lt;/p&gt;
&lt;p&gt;The reason to make them anyway is that one winning bet pays for all the rest: anyone could have completed your routine ticket work, whereas the value of a successful side bet happened entirely because of you. When a bet pays off, share it proactively via an internal write-up or a chat with your manager; if you feel awkward showing it off, the benefit probably wasn&amp;rsquo;t concrete enough. Goedecke shares examples from GitHub: an &amp;ldquo;open in prompt editor&amp;rdquo; button saw zero adoption, whereas wiring AI inference permissions into GitHub Actions saw real usage. He lands two or three winning bets a year—and notes that if your bets never pan out, it&amp;rsquo;s a sign to stop making them.&lt;/p&gt;
&lt;h2 id="avoiding-skill-atrophy-in-the-age-of-ai"&gt;&lt;a href="https://addyo.substack.com/p/avoiding-skill-atrophy-in-the-age" rel="noopener noreferrer"&gt;Avoiding Skill Atrophy in the Age of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani warns of the paradox of AI coding assistants: productivity goes up, but core skills can atrophy if you aren&amp;rsquo;t careful. A 2025 study by Microsoft and Carnegie Mellon found a correlation between higher trust in AI and lower self-reported critical thinking, though the findings don&amp;rsquo;t prove long-term skill loss. The warning signs creep in gradually: stopping reading documentation, pasting error messages straight into AI instead of debugging, copying code without understanding why it works, shying away from architectural design, and forgetting basic syntax. Osmani worries this erodes both individual learning and team mentorship. While letting go of obsolete skills is normal, the key is distinguishing which tasks can be safely offloaded to machines and which fundamentals must stay sharp.&lt;/p&gt;
&lt;p&gt;His prescription is to treat AI as a collaborator rather than a crutch: always verify and understand its output, actively hunt for bugs and edge cases, and ask AI to explain code line by line; schedule &amp;ldquo;no-AI days&amp;rdquo; to code from scratch and read docs directly; spend 15–30 minutes tackling a problem yourself before prompting; review AI-generated code as rigorously as a teammate&amp;rsquo;s PR; log topics you repeatedly ask AI about so you can fill those knowledge gaps; and use AI in a pair-programming style where you stay in the driver&amp;rsquo;s seat. The core message: use AI to amplify your capability rather than replace it, preserving both the craft and the joy of problem-solving.&lt;/p&gt;
&lt;h2 id="cursor-best-practices"&gt;&lt;a href="https://x.com/paraschopra/status/1917466537637859544" rel="noopener noreferrer"&gt;Cursor best practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://pbs.twimg.com/media/Gpw1p1waYAAeAyY?format=jpg" alt="Cursor best practices"&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 #32</title><link>https://miti99.com/en/post/2025/07/21/</link><pubDate>Mon, 21 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/21/</guid><description>&lt;p&gt;&lt;em&gt;It&amp;rsquo;s been a while since I last wrote a post. And honestly, my earlier newsletters felt a bit like &amp;ldquo;chasing KPIs&amp;rdquo;—&lt;del&gt;I just stuffed in a ton of links and let an AI Agent do the rest&lt;/del&gt;. This time I&amp;rsquo;ll curate the articles more carefully, &lt;del&gt;though I&amp;rsquo;m still letting AI do the writing because I&amp;rsquo;m lazy hehe =)))&lt;/del&gt;. Hope you enjoy it. Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="claude-code-best-practices-for-agentic-coding"&gt;&lt;a href="https://code.claude.com/docs/en/best-practices" rel="noopener noreferrer"&gt;Claude Code: Best Practices for Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official guide distilling effective workflows for Claude Code—an agentic coding environment that can read files, run commands, edit code, and work through problems while you supervise or steer. Most of its advice stems from a single constraint: the context window fills up fast, and response quality degrades as it fills. That makes giving Claude a way to verify its own work—such as a test suite, a build command, or screenshots to compare against—the single highest-leverage thing you can do, letting it iterate until the check passes instead of forcing you to catch every mistake yourself. For complex tasks, split the work into four phases: explore, plan (using plan mode), implement, and commit; for small fixes like a typo, just ask it to make the change directly.&lt;/p&gt;
&lt;p&gt;The guide also recommends writing specific prompts (naming files, edge cases, and existing project patterns) and configuring the environment thoughtfully: a concise &lt;code&gt;CLAUDE.md&lt;/code&gt; with project commands, conventions, and gotchas; an allowlist of safe permissions; CLI tools like &lt;code&gt;gh&lt;/code&gt;; MCP servers; hooks for deterministic checks; and skills or subagents for specialized knowledge. During a session, course-correct early, run &lt;code&gt;/clear&lt;/code&gt; between unrelated tasks, and delegate exploratory research to subagents to keep the main context clean. Once you have the basics down, you can scale out with non-interactive &lt;code&gt;claude -p&lt;/code&gt; runs, parallel sessions, and an independent review pass before considering a task done.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="openai-windsurf-and-the-future-of-work"&gt;&lt;a href="https://www.subtle.so/openai-windsurf-and-the-future-of-ai-workspaces.html" rel="noopener noreferrer"&gt;OpenAI, Windsurf, and the future of work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on Subtle analyzes reports that OpenAI wants to acquire Windsurf for around $3 billion, after previously eyeing Cursor. Technically, Windsurf&amp;rsquo;s core product (a VS Code fork with an AI agent and code autocomplete) isn&amp;rsquo;t uniquely hard to build, so the real value lies elsewhere: tools like this can become general-purpose AI workspaces far beyond coding. They give AI direct access to files and folders to assist with writing, research, and content management, while baking in Git for version history—something traditional productivity suites still lack. For instance, The Pragmatic Engineer connected Windsurf to a PostgreSQL database to query business metrics in plain English. The author compares this trajectory to how IRC evolved from a niche developer tool into Slack&amp;rsquo;s $27 billion business.&lt;/p&gt;
&lt;p&gt;On top of that, interaction data from millions of Windsurf sessions provides valuable training signal that could help OpenAI&amp;rsquo;s models catch up with Anthropic on coding benchmarks. The competitive web is tangled too: Microsoft owns both VS Code and GitHub Copilot while backing OpenAI, even as OpenAI&amp;rsquo;s startup fund has invested in Cursor. All of it points to a rapidly consolidating AI developer-tools market with massive commercial expectations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="vibe-coding-is-not-an-excuse-for-low-quality-work"&gt;&lt;a href="https://addyo.substack.com/p/vibe-coding-is-not-an-excuse-for" rel="noopener noreferrer"&gt;Vibe Coding is Not an Excuse for Low-Quality Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that &amp;ldquo;vibe coding&amp;rdquo; with AI is a useful accelerator, but not an excuse to abandon software engineering rigor. AI can generate huge amounts of code in minutes, yet volume does not equal quality: vibe-coded projects routinely skip error handling, miss security flaws, resist maintenance, and collapse like a &amp;ldquo;house of cards.&amp;rdquo; As Osmani puts it, speed means nothing if the wheels come off mid-drive, because technical debt compounds quickly when nobody is watching the architecture.&lt;/p&gt;
&lt;p&gt;His recommended mental model is to treat AI like a blazingly fast junior developer: a human still needs to review every output, refactor when needed, cover edge cases, and write thorough tests. He lays out practical rules: always review AI-generated code, enforce coding standards, use AI for acceleration rather than decision-making, prioritize testing, iterate and refine, recognize when to write code by hand, and document carefully. Vibe coding shines for rapid prototypes, throwaway scripts, learning a new stack, or generating boilerplate, but falls short for enterprise systems, mission-critical software, or long-lived codebases. That is also why experienced engineers get more out of AI—they know enough to spot flaws and refine its suggestions.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="event-hidden-architectures"&gt;&lt;a href="https://skiplabs.io/blog/event-hidden-arch" rel="noopener noreferrer"&gt;Event-Hidden Architectures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Zedlewski, an advisor to SkipLabs, argues that event-driven architecture—long treated as the default for distributed cloud applications—is showing its age, and proposes replacing it with &amp;ldquo;event-hidden&amp;rdquo; architectures. Distributed applications aren&amp;rsquo;t going away, but forcing developers to manage events by hand creates constant friction: juggling complex asynchronous flows, maintaining queues and schemas, and debugging across service boundaries. In his view, that complexity was a necessary tax around 2020, but no longer has to be.&lt;/p&gt;
&lt;p&gt;Three categories of technology make this shift possible: on the frontend, React and modern state-management libraries; on the backend write path, durable execution engines like Temporal, Restate, and DBOS that guarantee correctness across service boundaries; and on the read path, reactive frameworks like Skip that aggregate distributed data efficiently. What they share is hiding infrastructure plumbing, handling asynchrony transparently, and treating state as a first-class concern. That lets developers write simpler, more maintainable code while gaining better observability, cleaner state management, and the ability to replay application execution. Zedlewski predicts event-hidden architectures will become the default for web applications over the next decade.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="lessons-from-distributed-systems"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2025/04/19/lessons-from-distributed-systems/" rel="noopener noreferrer"&gt;Lessons from Distributed Systems&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from 16elt.com shares practical lessons from building and operating distributed systems at scale. The author distills hard-won experience around common failure modes and how to handle them when working with distributed architectures.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Isolate cache clusters: avoid sharing a single cache cluster across multiple services because a heavy workload from Service A can evict critical data needed by Service B, causing hard-to-diagnose performance issues&lt;/del&gt;
&lt;del&gt;- Use message queues: queues absorb traffic spikes and smooth service load, providing buffering and resilience between services like &amp;ldquo;a responsible adult in the room&amp;rdquo; that prevents service overload&lt;/del&gt;
&lt;del&gt;- Measure end-to-end latency: look beyond service response times to include &amp;ldquo;dequeue latency&amp;rdquo;—how long messages sit waiting in a queue before processing begins&lt;/del&gt;
&lt;del&gt;- Design for failure: expect and plan for network and service failures by implementing retry policies, circuit breakers, and dead-letter queues for failed messages&lt;/del&gt;
&lt;del&gt;- Ensure idempotency: assume duplicate messages will happen and design handlers to process repeated events gracefully, since message queues typically guarantee &amp;ldquo;at least once&amp;rdquo; delivery&lt;/del&gt;
&lt;del&gt;- Distributed systems demand proactive design, robust monitoring, and resilient architecture to keep complexity and failure points under control&lt;/del&gt;
&lt;del&gt;- Monitoring and observability are key to understanding how a system actually behaves in production&lt;/del&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="better-error-handling"&gt;&lt;del&gt;&lt;a href="https://meowbark.dev/Better-error-handling" rel="noopener noreferrer"&gt;Better error handling&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from meowbark.dev explores modern error-handling approaches in software development, from traditional try/catch blocks to Go-style error returns and monadic Result types. The author weighs the pros and cons of each style and offers guidance on choosing the right fit.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Three main approaches to error handling: traditional try/catch, Go-style return tuples, and monadic Result types&lt;/del&gt;
&lt;del&gt;- Challenges of traditional error handling: lack of type safety, unpredictable control flow, and limited integration with the type system&lt;/del&gt;
&lt;del&gt;- Go-style approach: return errors as part of a tuple, handle failure scenarios explicitly, and attach clear error context&lt;/del&gt;
&lt;del&gt;- Monadic Result approach: treat errors as values using container types like &lt;code&gt;Result&amp;lt;T,E&amp;gt;&lt;/code&gt;, enabling functional-style error chaining&lt;/del&gt;
&lt;del&gt;- Core best practices: distinguish recoverable from unrecoverable errors, wrap external library errors early, and use type-safe error-handling mechanisms&lt;/del&gt;
&lt;del&gt;- Weigh performance and developer experience when picking a strategy&lt;/del&gt;
&lt;del&gt;- Recommended techniques: use libraries like &lt;code&gt;neverthrow&lt;/code&gt; for structured error management, and implement error mapping and transformation&lt;/del&gt;
&lt;del&gt;- Build centralized error-handling layers to manage failures systematically&lt;/del&gt;
&lt;del&gt;- Choose an error-handling strategy that balances type safety, readability, and team familiarity&lt;/del&gt;
&lt;del&gt;- Maintain clear error communication and recovery paths across the application&lt;/del&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #27</title><link>https://miti99.com/en/post/2025/05/14/</link><pubDate>Wed, 14 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #27.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="heading"&gt;&lt;a href="https://blog.cloudflare.com/introducing-the-cloudflare-vite-plugin/" rel="noopener noreferrer"&gt;&amp;ldquo;Just use Vite&amp;rdquo;&amp;hellip; with the Workers runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced version 1.0 of the Cloudflare Vite plugin alongside official support for React Router v7. Previously, Vite&amp;rsquo;s development server always executed server-side code inside Node.js—even when the application targeted Cloudflare Workers in production—causing subtle, hard-to-catch discrepancies between local dev and production. Built on the experimental Environment API introduced in Vite 6, the new plugin runs your Worker code directly inside the native Workers runtime (&lt;code&gt;workerd&lt;/code&gt;) during local development, keeping dev behavior as close to production as possible.&lt;/p&gt;
&lt;p&gt;For single-page applications (SPAs) built with React, Vue, or Svelte, you can scaffold a new project with the &lt;code&gt;create-cloudflare&lt;/code&gt; CLI or migrate an existing app simply by adding &lt;code&gt;@cloudflare/vite-plugin&lt;/code&gt; to your Vite config and creating a &lt;code&gt;wrangler.jsonc&lt;/code&gt; file. When you edit server-side Worker code, Vite hot-reloads the Worker environment without losing client-side UI state in the browser. Running &lt;code&gt;vite build&lt;/code&gt; outputs both client and server bundles, &lt;code&gt;vite preview&lt;/code&gt; previews the production build inside the Workers runtime, and &lt;code&gt;wrangler deploy&lt;/code&gt; deploys straight to Cloudflare without an extra bundling step. With React Router v7 (the successor to Remix), a single entry file defines the Worker across both dev and build without needing a separate adapter, and the plugin supports the full Cloudflare Developer Platform including KV, D1, Durable Objects, and Workers AI.&lt;/p&gt;
&lt;h2 id="the-best-programmers-i-know"&gt;&lt;a href="https://endler.dev/2025/best-programmers/" rel="noopener noreferrer"&gt;The Best Programmers I Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthias Endler distills the common traits he has observed in the best programmers he has ever worked with—a list he wishes he had when starting out. First and foremost, they read the canonical reference documentation directly instead of guessing, copying from Stack Overflow, or asking an LLM. Second, they know their tools inside and out: why the tool was created, who maintains it, where its limits lie, and what the surrounding ecosystem looks like. Great programmers also actually read error messages carefully, break intimidating problems down into small, solvable steps, and aren&amp;rsquo;t afraid to get their hands dirty in unfamiliar codebases—which is how they become the go-to person on their team.&lt;/p&gt;
&lt;p&gt;Beyond raw technical chops, they generously help others, write clearly because clear writing reflects clear thinking, and never stop learning—some of the sharpest programmers Endler knows are in their 60s and still run circles around developers half their age. They don&amp;rsquo;t care about titles or hierarchy, build lasting reputation by shipping widely used work, stay patient with both computers and people, never blame &amp;ldquo;random&amp;rdquo; hardware glitches or compiler bugs before checking their own assumptions, aren&amp;rsquo;t afraid to say &amp;ldquo;I don&amp;rsquo;t know,&amp;rdquo; refuse to guess when requirements are ambiguous, and relentlessly favor simple code. Endler notes that this isn&amp;rsquo;t a checklist or a competition, just a reminder that there are no shortcuts around deliberate practice.&lt;/p&gt;
&lt;h2 id="rdel-87-how-do-ai-coding-tools-actually-change-developer-work"&gt;&lt;a href="https://rdel.substack.com/p/rdel-87-how-do-ai-coding-tools-actually" rel="noopener noreferrer"&gt;RDEL #87: How do AI coding tools actually change developer work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this installment of &lt;em&gt;Research-Driven Engineering Leadership&lt;/em&gt;, Lizzie Matusov summarizes a three-week randomized controlled trial conducted by Microsoft and the Institute for Work Life across 228 engineers at a global software company. Participants were split into three groups—engineers newly granted access to GitHub Copilot, a control group using no AI tools, and a comparison group of existing Copilot users—combining daily diary studies with system telemetry. Before the trial began, 86% of experienced Copilot users believed AI coding tools were useful compared to just 44% of non-users, and the single most common reason engineers hadn&amp;rsquo;t tried AI tools yet was simply being too busy.&lt;/p&gt;
&lt;p&gt;After three weeks, enjoyment and perceived usefulness rose significantly among the new users; 84% reported that Copilot positively changed how they worked, cutting down on tedious boilerplate and making coding more enjoyable. Engineers used Copilot not just for code completion, but also as a replacement for web search and as a sounding board for ideation and design. Interestingly, system telemetry showed no statistically significant difference in lines of code, pull request volume, or active coding time, and engineers&amp;rsquo; baseline level of trust in AI-generated code remained unchanged. Matusov advises engineering leaders to measure productivity holistically across satisfaction and flow using the SPACE framework, carve out dedicated time for teams to experiment, and view AI as a way to offload repetitive drudgery so engineers can focus on design and learning.&lt;/p&gt;
&lt;h2 id="overclocking-dbt-discord"&gt;&lt;a href="https://discord.com/blog/overclocking-dbt-discords-custom-solution-in-processing-petabytes-of-data" rel="noopener noreferrer"&gt;Overclocking dbt: Discord&amp;rsquo;s Custom Solution in Processing Petabytes of Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord data engineer Chris Dong shares how his team scaled &lt;code&gt;dbt&lt;/code&gt; (data build tool) to process petabytes of data across more than 100 developers collaborating on 2,500+ models. Their out-of-the-box setup quickly hit a wall: full project compilation took over 20 minutes, default incremental materialization strategies struggled at petabyte scale, and developers constantly clobbered each other&amp;rsquo;s test tables in shared environments. To isolate environments cleanly, they overrode the &lt;code&gt;generate_alias_name&lt;/code&gt; macro to automatically prefix table names with the developer&amp;rsquo;s username in local dev, the PR number or commit SHA in CI/CD, and the canonical name in production.&lt;/p&gt;
&lt;p&gt;On the performance side, they replaced standard &lt;code&gt;MAX(timestamp)&lt;/code&gt; incremental filtering with explicit &lt;code&gt;start_date&lt;/code&gt; and &lt;code&gt;end_date&lt;/code&gt; variables—noting that the expensive full-table scans came from the &lt;code&gt;MAX(timestamp)&lt;/code&gt; subquery in the old pattern rather than the &lt;code&gt;is_incremental()&lt;/code&gt; macro itself. They also patched partial-parsing hash mismatches and leveraged zero-copy BigQuery partition copies; together, these optimizations sped up runs by 5x. Historical backfills were automated via semantic versioning inside each model&amp;rsquo;s &lt;code&gt;meta&lt;/code&gt; config: bumping the major version triggers a full refresh of the table and all downstream dependents, while bumping the minor version runs a targeted date-chunked backfill. A shared macro library and Buildkite CI/CD pipeline validate query dry-run costs, dependencies, and blast radius before any change lands in production.&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 #25</title><link>https://miti99.com/en/post/2025/05/12/</link><pubDate>Mon, 12 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #25.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-13-software-engineering-laws"&gt;&lt;a href="https://newsletter.manager.dev/p/the-13-software-engineering-laws" rel="noopener noreferrer"&gt;The 13 software engineering laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides rounds up 13 classic &amp;ldquo;laws&amp;rdquo; every software engineer and engineering manager should know. On time and staffing: Parkinson&amp;rsquo;s Law (work expands to fill the time allotted) is counterbalanced by Hofstadter&amp;rsquo;s Law (it always takes longer than you expect), meaning estimation only improves through practice, communication, and flexible scope. Brooks&amp;rsquo;s Law reminds us that adding people to a late software project makes it later. Conway&amp;rsquo;s Law states that system architecture mirrors an organization&amp;rsquo;s communication structure; Flo applied the &amp;ldquo;Inverse Conway Maneuver&amp;rdquo; by embedding iOS, Android, and backend engineers into cross-functional teams to ship 20–30 releases per day. Cunningham&amp;rsquo;s Law offers a clever way to get unstuck: open a pull request—even if you aren&amp;rsquo;t sure it&amp;rsquo;s right—and the owning team will quickly jump in to show you the right way.&lt;/p&gt;
&lt;p&gt;On products and teams: Sturgeon&amp;rsquo;s Law (90% of everything is crud) and Zawinski&amp;rsquo;s Law (every program attempts to expand until it can read mail) warn against feature bloat, while Hyrum&amp;rsquo;s Law guarantees that with enough users, every observable behavior of your system will be depended on by someone, making removals painful. Price&amp;rsquo;s Law (half the work is done by the square root of the total number of contributors) and the Ringelmann Effect (individual effort drops as group size grows) explain why small teams with clear ownership outperform large ones. Goodhart&amp;rsquo;s Law (when a measure becomes a target, it ceases to be a good measure) is balanced by Gilb&amp;rsquo;s Law (imperfect measurement beats no measurement at all). Rounding out the list is Murphy&amp;rsquo;s Law. Zaides concludes that while these aren&amp;rsquo;t physical laws of nature, they are invaluable mental models.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-curve-is-bending-predictions-on-near-term-ai-inference-spending"&gt;&lt;a href="https://grantslatton.com/the-curve-is-bending" rel="noopener noreferrer"&gt;The Curve is Bending: Predictions on near-term AI inference spending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grant Slatton, creator of the high-performance spreadsheet engine Row Zero, argues that AI has just crossed an inflection point where the economic value it generates for real-world software engineering exceeds its cost. His personal AI spend jumped from $100/year in 2023 to roughly $5,000/year in 2025. For him, &lt;code&gt;o1-pro&lt;/code&gt; was the first model that felt reliably useful, performing on par with a junior engineer on self-contained single-file tasks—such as pinpointing a bug given a large Rust file, a git diff, and failing test output. He uses Zed Editor&amp;rsquo;s prompt library to generate repetitive spreadsheet functions (cutting 20 minutes of work down to 2), writes small LLM-powered CLI utilities for himself, and used Claude Code—sometimes running three sessions in parallel—to rewrite the entire backend of his personal website, finishing what he estimated as a 100-hour job in under 10 hours for a few hundred dollars.&lt;/p&gt;
&lt;p&gt;Looking ahead from April 2025, Slatton estimates AI tools currently boost his overall productivity by ~1.1x and expects that to reach 2–3x by late 2026. Frontier models like &lt;code&gt;o3-pro&lt;/code&gt; will initially be expensive, but for engineers earning over $100/hour, an annual AI inference budget of $10,000–$50,000 is easy to justify—and by Jevons paradox, falling per-token prices will only increase total spending. He notes that models still lack the architectural &amp;ldquo;taste&amp;rdquo; of a senior engineer, predicts coding agents will match new CS grads by the end of 2026, and advises junior developers to focus on cultivating senior-level judgment as quickly as possible.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="open-source-is-just-that-understanding-boundaries-in-open-source"&gt;&lt;a href="https://vale.rocks/posts/open-source-entitlement" rel="noopener noreferrer"&gt;Open-Source is Just That: Understanding Boundaries in Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Declan Chidlow speaks out against the growing sense of user entitlement directed at volunteer open-source maintainers. As Chidlow points out, open-source software grants specific rights defined by its license—and merely making source code public does not even make a project open source; it does not automatically mean a project accepts external contributions, offers user support, owes anyone new features, or owes anyone the maintainer&amp;rsquo;s personal time, and users remain bound by the license terms. Having permission to use code under a license does not entitle anyone to demand unpaid labor from its author. He criticizes users who spam issue trackers or aggressively demand support, commenters who defend that behavior, and especially profitable companies that build on open source without giving back instead of funding the maintainers they depend on.&lt;/p&gt;
&lt;p&gt;For projects that do welcome engagement, asking for help respectfully means searching existing issues and documentation first, providing complete reproduction details upfront, staying patient and polite, using official channels, and contributing small fixes or docs improvements where you can—and even when you sponsor or pay a maintainer, &amp;ldquo;money does not replace manners.&amp;rdquo; He encourages the community to respectfully stand up for maintainers, urges maintainers to set firm boundaries, and warns against flooding projects with thoughtless AI-generated issues and pull requests. The bottom line: access to source code is not access to someone else&amp;rsquo;s time and labor.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-insanity-of-being-a-software-engineer"&gt;&lt;a href="https://0x1.pt/2025/04/06/the-insanity-of-being-a-software-engineer/" rel="noopener noreferrer"&gt;The Insanity of Being a Software Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitor Sousa Pereira takes a satirical look at the ever-expanding mountain of knowledge a single software engineer is expected to master. At first, you just needed a couple of languages and tools, plus your company&amp;rsquo;s web framework of choice—Rails, Django, or Laravel—alongside CSS, which you can study your whole life and still not understand why a layout broke. Then React arrived, companies decided they didn&amp;rsquo;t want to hire separate specialists, and the &amp;ldquo;full-stack developer&amp;rdquo; was born—bringing TypeScript, Redux, webpack/esbuild/rollup configs, Prettier, and ESLint along for the ride. Next, DevOps replaced dedicated sysadmins, so developers had to learn Docker, AWS, and Terraform or Pulumi too. Getting promoted into management means learning an entirely new profession—estimating timelines, delegating, writing specs, running annual performance reviews—and unless the company is growing fast, you still have to do all your old IC work on top of it.&lt;/p&gt;
&lt;p&gt;Pereira mentions a recruiter recently reaching out for a role demanding senior-level expertise across Rails, Hotwire, &lt;em&gt;and&lt;/em&gt; native mobile development simultaneously. While acknowledging that software complexity exists for real reasons, he asks what happened to specialization: when building a house, you hire an architect, a structural engineer, an electrician, a plumber, and dozens of other trades—nobody expects one person to do it all. He closes half-jokingly that maybe a future where we build entire applications with a few AI prompts wouldn&amp;rsquo;t be so bad after all.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-day-i-taught-ai-to-understand-code-like-a-senior-developer"&gt;&lt;a href="https://nmn.gl/blog/ai-understand-senior-developer" rel="noopener noreferrer"&gt;The day I taught AI to understand code like a Senior Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Namanyay argues that today&amp;rsquo;s code-generating LLMs don&amp;rsquo;t truly understand a codebase—they act like glorified autocomplete tools that forget where files live, duplicate existing helpers, and ignore established design patterns because they only see a narrow context window. Junior developers focus on the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; whereas senior developers focus on the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;what if,&amp;rdquo; holding a mental model of the entire system and anticipating ripple effects; current LLMs behave much more like juniors. His solution is modeling the codebase as a hierarchical knowledge graph using an algorithm he calls Ranked Recursive Summarization (RRS): starting at leaf files, ranking their importance, and recursively summarizing upward into parent directories. Because plain RRS still lost domain-specific nuance, he evolved it into Prismatic RRS (PRRS), which summarizes the codebase through multiple &amp;ldquo;prisms&amp;rdquo; such as architecture, data flow, and security.&lt;/p&gt;
&lt;p&gt;With this multi-perspective context, the AI knows where new files belong, which patterns to follow, and how to extend existing abstractions instead of reinventing them—while also surfacing technical debt, security gaps, and speeding up onboarding for human engineers. He packaged this approach into a product called Giga AI, but also shares how developers can apply the idea manually: write concise summaries for key directories and files, have AI refine them, maintain perspective-specific docs, and feed the relevant summaries into context. His core belief: AI should amplify human creativity rather than replace it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="why-companies-don"&gt;&lt;a href="https://idiallo.com/blog/companies-dont-fix-bugs" rel="noopener noreferrer"&gt;Why Companies Don&amp;rsquo;t Fix Bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ibrahim Diallo opens with the famous GTA Online story: a player named &lt;code&gt;t0st&lt;/code&gt; diagnosed why the game&amp;rsquo;s online mode took 20 minutes to load, fixed it with 13 lines of code that cut load times by 70%, and was awarded $10,000 by Rockstar—after the bug had sat in production for eight years. Rather than blaming &amp;ldquo;lazy developers,&amp;rdquo; Diallo traces the typical lifecycle of a bug inside a large company: in year one, an engineer proposes fixing the slow JSON parser, the product manager asks &amp;ldquo;is it in the spec?&amp;rdquo;, and it gets filed under tech debt; by year three, all engineering capacity is locked into expansion packs and paid cosmetics; by year six, the ticket is auto-archived because the codebase has been rewritten twice; in year eight, a newly hired developer discovers the exact same bug all over again.&lt;/p&gt;
&lt;p&gt;He identifies four structural reasons bugs go unfixed: roadmap-driven development pushes any fix not tied to a feature request to the bottom of the backlog; constant employee turnover erodes institutional knowledge; touching poorly tested, undocumented legacy code carries high career risk for little reward; and quality-of-life improvements don&amp;rsquo;t show up on quarterly revenue charts the way selling virtual Shark Cards does. &lt;code&gt;t0st&lt;/code&gt;&amp;rsquo;s fix was a great PR win, but it didn&amp;rsquo;t change the underlying incentives. The takeaway: don&amp;rsquo;t blame individual engineers when the system itself treats user experience as an afterthought.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="3-buckets-of-work-time"&gt;&lt;a href="https://corymiller.com/3-buckets-of-work-time/" rel="noopener noreferrer"&gt;3 Buckets of Work Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cory Miller, a Chief Evangelist working remotely from Oklahoma with a largely European team, audited his calendar and realized his workweek falls into three buckets. The first is &lt;em&gt;talking&lt;/em&gt;—communication and collaboration across meetings and Slack/Teams—which has been taking a larger share than usual since he recently joined a new team. The second is &lt;em&gt;doing&lt;/em&gt;—execution and shipping—which for him mostly means producing internal and customer-facing videos. The third is &lt;em&gt;thinking about work&lt;/em&gt;—strategy and vision, the &amp;ldquo;daydreaming&amp;rdquo; bucket tied to his Wonder and Invention strengths in the Working Genius model, best done alone in quiet reflection before bringing rough ideas back to teammates for feedback.&lt;/p&gt;
&lt;p&gt;Now in his late 40s, having lived through burnout before and raising two young kids with his wife, Miller has no interest in working 60-hour weeks; he wants to work smarter and healthier. He admits that fear and uncertainty often drive him to overcommit, so he is practicing letting go of what he can&amp;rsquo;t control. Wanting enough structure to feel grounded without feeling boxed in, he is experimenting with waking up at 6 a.m. to handle European overlap and communication early, dedicating Mondays and Wednesdays to collaboration, and reserving Tuesdays and Thursdays for deep work and strategic thinking—leaving himself more quiet space to embrace &amp;ldquo;not knowing yet.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="dangerous-advice-for-software-engineers"&gt;&lt;a href="https://www.seangoedecke.com/dangerous-advice/" rel="noopener noreferrer"&gt;Dangerous Advice for Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke compares certain kinds of career advice to &amp;ldquo;sharp tools&amp;rdquo; like &lt;code&gt;ssh&lt;/code&gt;, &lt;code&gt;kubectl&lt;/code&gt;, or write access to a production database: wielded with skill and judgment, they are indispensable; used carelessly, they cause serious damage. Goedecke admits he frequently writes this kind of &amp;ldquo;dangerous&amp;rdquo; advice: deciding for yourself what to work on, occasionally breaking written company rules on purpose, holding strong opinions before you have all the facts, embracing a bit of organizational cunning, and avoiding work that doesn&amp;rsquo;t directly serve shipping. He worries about readers misapplying it, but argues someone still needs to write it down.&lt;/p&gt;
&lt;p&gt;First, most mainstream career advice is sanitized—written to avoid liability or sound virtuous—while strong engineers crave honest talk about how organizations actually work; realizing that reality doesn&amp;rsquo;t match the employee handbook while nobody admits it out loud is deeply isolating. Second, your own manager can almost never give you this advice directly: if you misjudge a situation and say &amp;ldquo;my manager told me to break the process,&amp;rdquo; the fallout hits them even harder than it hits you, even though many managers quietly wish their reports operated with more pragmatic initiative than their job description states. This advice is high-risk, high-reward—helpful for strong engineers and dangerous for weaker ones—so if any piece of it makes you uncomfortable, don&amp;rsquo;t follow it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="on-the-biology-of-a-large-language-model"&gt;&lt;a href="https://transformer-circuits.pub/2025/attribution-graphs/biology.html" rel="noopener noreferrer"&gt;On the Biology of a Large Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This landmark Anthropic paper uses &amp;ldquo;circuit tracing&amp;rdquo; to study the internal mechanisms of Claude 3.5 Haiku, likening the approach to a biologist studying living tissue under a microscope. The researchers train a replacement model built on a cross-layer transcoder architecture containing roughly 30 million interpretable &amp;ldquo;features&amp;rdquo; (replacement neurons that typically correspond to human-understandable concepts), then construct attribution graphs for individual prompts to trace how features activate one another step by step. Because attribution graphs are hypotheses, they validate them with intervention experiments—such as inhibiting specific feature clusters inside the original model and observing how behavior changes across multi-step reasoning, poetry, multilingual understanding, addition, medical diagnosis, hallucinations, refusals, jailbreaks, and chain-of-thought faithfulness.&lt;/p&gt;
&lt;p&gt;Their experiments reveal that the model performs genuine multi-step intermediate reasoning &amp;ldquo;in its head&amp;rdquo;—for example, activating &amp;ldquo;Texas&amp;rdquo; before arriving at &amp;ldquo;Austin&amp;rdquo; when asked for the capital of the state containing Dallas—alongside memorized shortcuts. It shows clear signs of forward planning, choosing a rhyming target word before composing a line of poetry; possesses rudimentary &amp;ldquo;metacognitive&amp;rdquo; circuits that track what it knows versus doesn&amp;rsquo;t know; and operates on shared abstract representations across languages. While the authors acknowledge their current tools yield satisfying explanations for only about a quarter of prompts, the work represents a major step forward for AI interpretability and safety.&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 #19</title><link>https://miti99.com/en/post/2025/05/06/</link><pubDate>Tue, 06 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #19.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-love-letter-to-the-csv-format"&gt;&lt;a href="https://github.com/medialab/xan/blob/master/docs/LOVE_LETTER.md" rel="noopener noreferrer"&gt;A love letter to the CSV format&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of &lt;code&gt;xan&lt;/code&gt; (a command-line CSV processing tool developed by medialab) wrote this &amp;ldquo;love letter&amp;rdquo; to push back against articles constantly declaring CSV obsolete in the face of Parquet, newline-delimited JSON, or MessagePack. CSV is no silver bullet, the author admits, but it has strengths that are routinely overlooked: a specification simple enough to explain in seconds (commas separate values, newlines separate rows, special values go in quotes), no corporate owner, and plain-text representation that humans can read and edit directly. CSV can also be streamed row by row with minimal memory and supports efficient append-only writes at the end of a file—things columnar formats like Parquet handle much worse, even if columnar formats excel when querying only a few columns.&lt;/p&gt;
&lt;p&gt;Beyond that, CSV is dynamically typed, leaving each language free to decide how to parse values (both flexible and error-prone if you&amp;rsquo;re careless), and remarkably compact since column names appear only once in the header rather than repeating keys on every record like JSON or XML. Even more uniquely, because escaping double quotes by doubling them is symmetrical, a CSV file reversed byte-for-byte is still valid CSV; this makes it possible to quickly read the last few rows of a massive file from the end, which is handy when resuming an interrupted job. The author jokes in closing that Excel hates CSV, which is probably a sign CSV is doing something right. For newer developers, the piece is a good reminder to pick data formats based on the actual problem rather than chasing trends.&lt;/p&gt;
&lt;h2 id="the-role-of-developer-skills-in-agentic-coding"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/13-role-of-developer-skills.html" rel="noopener noreferrer"&gt;The role of developer skills in agentic coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) reflects on months of using the agent modes of Cursor, Windsurf, and Cline to modify existing codebases. She appreciates how these tools can automatically run tests, fix compiler errors, and search the web, but notes that even in her most successful sessions, she constantly had to step in and steer. She categorizes AI mistakes into three &amp;ldquo;blast radii&amp;rdquo;: slowing down completion of a single commit (broken code or misdiagnosed problems, like blaming Docker&amp;rsquo;s architecture settings when the real issue was &lt;code&gt;node_modules&lt;/code&gt; built for the wrong architecture); creating friction for the team across development iterations (tackling too much at once instead of working in small vertical slices, treating symptoms by bumping memory limits instead of finding the root cause, or making the dev workflow messier); and most dangerously, degrading long-term maintainability (redundant tests, poor reuse, unnecessary verbosity). The wider the blast radius, the longer the feedback loop to catch the problem.&lt;/p&gt;
&lt;p&gt;In her view, we are nowhere near AI autonomously writing 90% of code within a year; right now, AI assists her roughly 80% of the time on a small ~15k-line project. To mitigate risks, individual developers should carefully review AI-generated code, stop sessions when cognitive load gets too high, stay wary of &amp;ldquo;good enough&amp;rdquo; solutions that appear too quickly, and practice pair programming. At the team level, she recommends maintaining code quality monitors like SonarQube or CodeScene, running checks in pre-commit hooks, curating custom rule files for AI assistants, and fostering a culture of trust and openness so nobody feels pressured to cut corners just to ship faster. For junior developers, the article clearly highlights the engineering skills that still matter in the AI era.&lt;/p&gt;
&lt;h2 id="cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes"&gt;&lt;a href="https://dev.to/prodevopsguytech/cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes-4fi2" rel="noopener noreferrer"&gt;CI/CD DevOps Pipeline Project: Deployment of Java Application on Kubernetes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community tutorial walks through building an end-to-end CI/CD pipeline from scratch to deploy a Java application onto Kubernetes, aiming to automate the entire software delivery lifecycle with minimal manual intervention. The infrastructure spans AWS EC2 instances for the Kubernetes master, worker nodes, Jenkins, SonarQube, Nexus, and a monitoring server. The author details setting up the cluster with Kubeadm (disabling swap, installing the CRI-O runtime and Kubernetes packages, initializing the control plane, and joining worker nodes), installing Jenkins, Docker, and Nexus, and setting up a private Git repository with a personal access token.&lt;/p&gt;
&lt;p&gt;At the heart of the guide is the &lt;code&gt;Jenkinsfile&lt;/code&gt;: the pipeline checks out the source code, compiles and runs tests with Maven, scans for vulnerabilities with Trivy, analyzes code quality via SonarQube, packages and uploads artifacts to Nexus, builds and pushes the Docker image, deploys to Kubernetes, and sends status notifications. The final section sets up real-time observability using Prometheus, Blackbox Exporter, and Grafana. It makes a solid hands-on project for developers who want to see how common DevOps tools fit together into a single cohesive workflow.&lt;/p&gt;
&lt;h2 id="road-to-jdk-25-over-engineering-tic-tac-toe-java-24"&gt;&lt;a href="https://briancorbinxyz.medium.com/road-to-jdk-25-over-engineering-tic-tac-toe-java-24-565c7f9b06d0" rel="noopener noreferrer"&gt;Road to JDK 25: Over-Engineering Tic-Tac-Toe (Java 24)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his &amp;ldquo;Road to JDK 25&amp;rdquo; series, Brian Corbin explores new Java features by deliberately over-engineering a simple tic-tac-toe game. This installment covers JDK 24—which includes 24 JEPs—focusing on finalized, non-preview features. The standout addition is Stream Gatherers: using &lt;code&gt;Stream::gather(Gatherer)&lt;/code&gt;, developers can define custom stateful or stateless intermediate Stream operations with one-to-one, one-to-many, many-to-one, or many-to-many semantics, alongside built-in gatherers like &lt;code&gt;fold&lt;/code&gt;, &lt;code&gt;scan&lt;/code&gt;, &lt;code&gt;windowFixed&lt;/code&gt;, and &lt;code&gt;windowSliding&lt;/code&gt;. The ZGC garbage collector is now exclusively generational, collecting short-lived objects more frequently and efficiently.&lt;/p&gt;
&lt;p&gt;Other highlights include a standard Class-File API for reading, generating, and transforming &lt;code&gt;.class&lt;/code&gt; files (foundational for bytecode tooling), Ahead-of-Time Class Loading &amp;amp; Linking to cut startup times, and two quantum-resistant lattice-based cryptographic algorithms for key encapsulation and digital signatures. Each feature is demonstrated directly inside the tic-tac-toe codebase, and Corbin notes that JDK 25, the next LTS release, arrives in September 2025.&lt;/p&gt;
&lt;h2 id="oracle-reveals-five-new-features-coming-to-java"&gt;&lt;a href="https://www.infoworld.com/article/3848288/oracle-reveals-five-new-features-coming-to-java.html" rel="noopener noreferrer"&gt;Oracle reveals five new features coming to Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Right on the heels of JDK 24&amp;rsquo;s general availability, Oracle previewed five features in the pipeline for upcoming Java releases; all have JEPs, though none are finalized yet (for instance, JEP 402 is still a Draft and JEP 468 is a Candidate). Enhanced primitive boxing makes primitive types behave more like reference types, such as calling methods directly on primitive values or using primitives as type arguments. Value classes and objects introduce identity-free objects with only &lt;code&gt;final&lt;/code&gt; fields, distinguished purely by their field values so the JVM can optimize memory layout, locality, and garbage collection. Paired with this are null-restricted value class types, allowing variables of value types to forbid &lt;code&gt;null&lt;/code&gt; for denser storage.&lt;/p&gt;
&lt;p&gt;Derived record creation provides concise syntax for creating a new record from an existing one without writing boilerplate &amp;ldquo;wither&amp;rdquo; methods (the immutable equivalent of setters). Finally, Stable Values—confirmed as a preview feature in JDK 25 (September 2025)—are objects holding immutable data that the JVM treats as constants, delivering &lt;code&gt;final&lt;/code&gt;-like performance optimizations with more flexible initialization timing to improve application startup. Together, these proposals show Java steadily modernizing both its object model and its runtime performance.&lt;/p&gt;
&lt;h2 id="java-bytecode-hacking-for-fun-and-profit"&gt;&lt;a href="https://cory.li/bytecode-hacking/" rel="noopener noreferrer"&gt;Java bytecode hacking for fun and profit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares Java bytecode optimization techniques learned from Battlecode, a programming competition where AI bots control virtual robots and each turn is capped by a strict bytecode execution limit (roughly 6,000–10,000 bytecodes) rather than wall-clock CPU time. While manual bytecode golfing has been rare in everyday Java ever since JIT compilers matured, it can decide wins and losses in Battlecode. The post explains that the JVM is a stack-based virtual machine where each bytecode is an atomic instruction akin to assembly, and Battlecode counts instructions regardless of byte width—so &lt;code&gt;iload_0&lt;/code&gt; and &lt;code&gt;iload #5&lt;/code&gt; each cost one instruction.&lt;/p&gt;
&lt;p&gt;By inspecting decompiled bytecode, the author demonstrates several concrete tricks: rewriting enhanced &lt;code&gt;for-each&lt;/code&gt; loops manually to shave a few instructions per iteration, copying instance fields into local variables because every field access costs an extra instruction, comparing against zero wherever possible since the JVM has dedicated zero-comparison opcodes, and using labeled &lt;code&gt;break&lt;/code&gt;/&lt;code&gt;continue&lt;/code&gt; statements to force the compiler to emit direct &lt;code&gt;goto&lt;/code&gt; jumps that skip unnecessary loop tails. The author stresses that you should only optimize at this level after finalizing your core AI framework and algorithms, as correctness and algorithmic efficiency always come first. Even if you rarely need this at work, it&amp;rsquo;s a fun way to see how Java actually executes under the hood.&lt;/p&gt;
&lt;h2 id="how-to-write-blog-posts-that-developers-read"&gt;&lt;a href="https://refactoringenglish.com/chapters/write-blog-posts-developers-read/" rel="noopener noreferrer"&gt;How to Write Blog Posts that Developers Read&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch, who has written a software blog for nine years reaching 300,000–500,000 readers annually, shares principles for writing technical blog posts developers actually read; the piece is a sample chapter from his upcoming book on writing for software developers. His first rule is to get straight to the point: your title and opening sentences should immediately tell readers who the post is for and what they will get out of it. Next is &amp;ldquo;think one level broader&amp;rdquo;: adding just a couple of sentences explaining background concepts or swapping niche jargon for plain language can open the article to a vastly larger audience. He also emphasizes having a realistic distribution path—such as Hacker News, Reddit, or Google search—rather than simply writing something good and hoping people find it.&lt;/p&gt;
&lt;p&gt;The remaining two rules focus on presentation. Adding visuals is the single highest-leverage improvement: screenshots, charts, diagrams—even a clumsy MS Paint drawing is far more engaging than AI-generated art. Finally, cater to skimmers, since many readers scan headings and images before deciding whether to read word for word; Lynch even provides a bookmarklet that blurs body text so you can preview your post through a skimmer&amp;rsquo;s eyes. Every principle is backed by examples from his own blog and applies just as well to internal design docs and workplace emails.&lt;/p&gt;
&lt;h2 id="the-new-look-and-feel-of-apache-kafka-40"&gt;&lt;a href="https://thenewstack.io/the-new-look-and-feel-of-apache-kafka-4-0/" rel="noopener noreferrer"&gt;The New Look and Feel of Apache Kafka 4.0&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Apache Kafka 4.0 brings upgrades across nearly every component of the distributed event streaming platform, but the headline change is running exclusively in KRaft (Raft-based) mode and removing ZooKeeper mode entirely. As Sandon Jacobs (Confluent) explains, this transition was prepared across multiple releases; operations teams no longer need to provision and manage a separate ZooKeeper cluster, configure TLS between two systems, or allocate dedicated compute for it—one less component means one less point of failure. The release also includes early access to Queues for Kafka (KIP-932), allowing the number of consumers to exceed a topic&amp;rsquo;s partition count so it behaves like traditional message queues such as Amazon SQS; the trade-off is that message ordering is not guaranteed, so ordered workloads should stick with traditional consumer groups.&lt;/p&gt;
&lt;p&gt;In addition, KIP-848 introduces a new consumer group protocol that eliminates stop-the-world rebalances; in Kafka 4.0, clients opt in via &lt;code&gt;group.protocol=consumer&lt;/code&gt;. KIP-1112 lets developers declare a processor wrapper applied across every processor in a Kafka Streams topology instead of manually duplicating cross-cutting logic like audit logging everywhere. Finally, KIP-1076 and KIP-1091 expand client and broker metrics that can be pushed over OpenTelemetry to observability tools like Datadog. For developers working with streaming data, Kafka 4.0 makes operations substantially simpler.&lt;/p&gt;
&lt;h2 id="five-things-ai-will-not-change"&gt;&lt;a href="https://metastable.org/five/" rel="noopener noreferrer"&gt;Five Things AI Will Not Change&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Inspired by how Jeff Bezos built Amazon around things customers will always want (low prices, fast delivery, vast selection) rather than trying to predict the future of the internet, the author outlines five things that won&amp;rsquo;t change even with powerful AI. First, there will be many AIs rather than a single superintelligence, because fierce competition prevents any one lab from holding a monopoly for long. Second, rogue or malicious AIs will always exist, created intentionally or accidentally by humans, much like the social media manipulation campaigns seen in the 2016 US election. Third, abundance will not be distributed equally: AI cannot manufacture more land or scarce physical resources, so money will still be needed to allocate them. Fourth, politics will remain deeply divided, because many disagreements stem from conflicting values rather than a lack of information. Fifth, humans will not become &amp;ldquo;ants&amp;rdquo; to AI, because AI is trained on human culture and will converse directly with us on every subject.&lt;/p&gt;
&lt;p&gt;In the closing section, the author explains why the 2023 open letter calling for a pause on giant AI experiments was never going to succeed: humanity is still fighting cancer, Alzheimer&amp;rsquo;s, pandemics, and poverty, and AI holds real promise for helping solve them. In the author&amp;rsquo;s view, both the AI doomers and the utopians are wrong; the future will be messy and occasionally dark, but also beautiful and inspiring.&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/5321bec2-0079-47e2-92e9-1cd9950227c8_2250x2624.png" alt="Object Oriented Programming Fundamentals"&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 #18</title><link>https://miti99.com/en/post/2025/05/05/</link><pubDate>Mon, 05 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #18.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="no-longer-my-favorite-git-commit"&gt;&lt;a href="https://mtlynch.io/no-longer-my-favorite-git-commit/" rel="noopener noreferrer"&gt;No Longer My Favorite Git Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch revisits the commit famously praised by David Thompson in &amp;ldquo;My favourite Git commit&amp;rdquo;: a six-paragraph commit message with five code snippets that painstakingly narrates a debugging journey just to explain replacing a single whitespace character. Lynch acknowledges that the message is valuable for searchability and for showing how the author investigated the bug, but points out three flaws: the most important takeaway is buried at the very end, the root cause is never clearly explained, and references to external source code lack links or commit hashes so readers cannot reproduce the trail. Digging into it himself, Lynch discovered the culprit was a UTF-8 non-breaking space that had accidentally slipped into a &lt;code&gt;routes.conf.erb&lt;/code&gt; template while Ruby 1.9.3 defaulted to reading files as US-ASCII, causing the test suite to fail.&lt;/p&gt;
&lt;p&gt;From there, he rewrites the commit message using journalism&amp;rsquo;s &amp;ldquo;inverted pyramid&amp;rdquo; style: opening with a concise summary of the change, followed by the root cause and fix, and only then a &amp;ldquo;How I discovered this&amp;rdquo; section containing most of the original narrative, complete with a link to the commit that introduced the stray character. The lesson for junior developers: technical context is worth keeping, but structure your commit messages so anyone scanning the commit log immediately understands what changed and why.&lt;/p&gt;
&lt;h2 id="our-interfaces-have-lost-their-senses"&gt;&lt;a href="https://wattenberger.com/thoughts/our-interfaces-have-lost-their-senses" rel="noopener noreferrer"&gt;Our interfaces have lost their senses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amelia Wattenberger argues that digital interfaces have grown increasingly flat and sensory-deprived. Early computing was a full-body experience of punch cards, patch cables, and switches; then came command lines, graphical interfaces with skeuomorphic buttons, and finally touchscreens where everything sits behind a sheet of glass. With the wave of AI chatbots, we have lost even texture, color, and shape: whether editing a photo, tweaking settings, or learning a subject, everything is reduced to a single text input box. She notes that removing all friction also strips away meaning: doomscrolling social media is effortless, but kneading dough, playing an instrument, or sketching is what brings real satisfaction. In her words, we have turned painting into typing, when we should have made typing feel more like painting.&lt;/p&gt;
&lt;p&gt;Her proposed direction is designing interfaces that fit the human body: computers can respond through text, rich visuals, sound, and haptics, while humans can provide input via keyboards, drag-and-drop, touch gestures, body movement, and voice. The real power lies in combining multiple modalities at once, such as speaking while pointing and clicking. She envisions future interfaces where we collaborate on tangible artifacts rather than just chat histories, use multiple modalities simultaneously, and have tools respond to ambient context—illustrated by an experimental prototype that automatically organizes a user&amp;rsquo;s thoughts into visual cards as they speak or type.&lt;/p&gt;
&lt;h2 id="labeled-breaks-in-java-useful-tool-or-code-smell"&gt;&lt;a href="https://www.baeldung.com/java-labeled-break" rel="noopener noreferrer"&gt;Labeled Breaks in Java: Useful Tool or Code Smell?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Leo Helfferich&amp;rsquo;s article on Baeldung examines labeled &lt;code&gt;break&lt;/code&gt; and &lt;code&gt;continue&lt;/code&gt; statements in Java, a feature present since Java 1.0 and largely unchanged since. Unlike an unlabeled &lt;code&gt;break&lt;/code&gt;, which only exits the innermost loop, a labeled break jumps straight out of a named outer loop—for instance, &lt;code&gt;break outer;&lt;/code&gt; in the snippet below terminates both nested loops at once. The advantage is efficiency: when searching through nested collections, you can stop immediately upon finding a match without extra flag variables or auxiliary conditions, while explicitly controlling which loop terminates in deeply nested structures.&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;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;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&lt;/span&gt;&lt;span class="lnt"&gt;9
&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="nl"&gt;outer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="c1"&gt;// &amp;lt;-- label&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="k"&gt;for&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&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;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="k"&gt;for&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&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;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;i&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="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;j&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="k"&gt;if&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;j&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;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="k"&gt;break&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;outer&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="c1"&gt;// exit the outer loop&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;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;span class="line"&gt;&lt;span class="cl"&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;p&gt;On the flip side, labels can easily make code read like &lt;code&gt;GOTO&lt;/code&gt; statements and confuse maintainers, especially with arbitrary label names like &lt;code&gt;x:&lt;/code&gt;; modifying a labeled loop in a large codebase can also subtly break dependent logic. The author suggests clearer alternatives such as extracting loop logic into a separate method or using the Stream API with &lt;code&gt;flatMap&lt;/code&gt; and &lt;code&gt;anyMatch&lt;/code&gt;. The post also compares Java&amp;rsquo;s syntax with Kotlin (&lt;code&gt;outer@&lt;/code&gt; and &lt;code&gt;break@outer&lt;/code&gt;) and JavaScript (nearly identical to Java), concluding that labeled breaks should remain a niche tool for rare, complex scenarios where they don&amp;rsquo;t hurt readability.&lt;/p&gt;
&lt;h2 id="distributed-locking-a-practical-guide"&gt;&lt;a href="https://www.architecture-weekly.com/p/distributed-locking-a-practical-guide" rel="noopener noreferrer"&gt;Distributed Locking: A Practical Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Oskar Dudycz explains distributed locking—the mechanism ensuring only one process operates on a shared resource at a time when an application runs across multiple machines or microservices. It is needed when multiple processes update the same record, when messages may be delivered more than once, or when scheduled jobs run across multiple nodes. The basic flow is simple: a node requests a lock from a lock manager, acquires it if free, performs its critical work, and releases it; if the node crashes, a TTL or ephemeral node automatically clears the lock to prevent &amp;ldquo;zombie&amp;rdquo; locks. Dudycz compares four common options: Redis with &lt;code&gt;SET ... NX EX&lt;/code&gt;, which is simple and fast but risky during network partitions; ZooKeeper/etcd, which offer strong consistency via quorum consensus at the cost of heavier operations; database locks like &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; or PostgreSQL advisory locks, which are convenient when you already have a single database but harder to scale; and running a single replica on Kubernetes, which avoids locking altogether but sacrifices scalability, high availability, and can still briefly run two pods during rollouts.&lt;/p&gt;
&lt;p&gt;The article also covers pitfalls like deadlocks, lock contention, single points of failure, clock skew, and network partitions. Crucially, a TTL only prevents a lock from staying stuck forever: an expired lock does not stop the original process from continuing its work, so you still have to account for long pauses or lost connections. His closing advice: avoid distributed locks if you can, use them sparingly since excessive locking kills parallelism, pick a tool that fits your existing infrastructure, and always plan for failures with time-bounded locks.&lt;/p&gt;
&lt;h2 id="if-it-is-worth-keeping-save-it-in-markdown"&gt;&lt;a href="https://p.migdal.pl/blog/2025/02/markdown-saves" rel="noopener noreferrer"&gt;If it is worth keeping, save it in Markdown&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Piotr Migdał opens with an uncomfortable truth: content posted online eventually disappears. Links rot when websites restructure, platforms shut down or lock posts behind logins and paywalls, and even self-hosted sites vanish due to forgotten domain renewals or botched database upgrades. The most durable solution, he argues, is UTF-8 plain text in Markdown format: any computer can read it without proprietary software, and Markdown&amp;rsquo;s deliberate lack of fine-grained styling control is actually a strength under the &amp;ldquo;rule of least power.&amp;rdquo; He uses Obsidian for personal notes and a static site generator for his blog—both store plain Markdown files, making sharing and platform migrations effortless.&lt;/p&gt;
&lt;p&gt;His workflow is pragmatic: whenever he comes across something worth keeping, he copies it into a Markdown file with YAML frontmatter recording the publication date, source, and tags; whenever he catches himself searching for something a second time, he saves it immediately, because anything worth looking up twice is worth keeping forever. His toolkit includes &lt;code&gt;pandoc&lt;/code&gt; for format conversion, specialized exporters for Medium or Reddit, AI for extracting text from PDFs, and Git for versioning and backups. He also periodically exports data archives from services he uses, even before converting them into Markdown.&lt;/p&gt;
&lt;h2 id="the-software-engineering-identity-crisis"&gt;&lt;a href="https://annievella.com/posts/the-software-engineering-identity-crisis/" rel="noopener noreferrer"&gt;The Software Engineering Identity Crisis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Vella examines the identity crisis facing software engineers in the age of AI. Many developers entered the field for the joy of building things with their own hands—tracking down an elusive bug or optimizing a slow algorithm—but AI coding assistants are turning them from creators into orchestrators, from builders into supervisors. The shift is already underway: Google reports that AI generates more than a quarter of its new code, and Y Combinator&amp;rsquo;s CEO noted that roughly a quarter of a recent batch had 95% of their code written by AI. Andrej Karpathy&amp;rsquo;s concept of &amp;ldquo;vibe coding,&amp;rdquo; which focuses on the &amp;ldquo;what&amp;rdquo; rather than the &amp;ldquo;how,&amp;rdquo; raises an existential question: are we still engineers if we forget the code exists? Vella relates this to her own reluctant transition into engineering management, while citing GitClear research showing sharp rises in copy-pasted and churned code, alongside studies showing that trust in AI often starts high before dropping sharply with experience.&lt;/p&gt;
&lt;p&gt;Still, the piece is not pessimistic. Like artisans during the Industrial Revolution, engineers can adapt, and durable skills such as communication, systems thinking, and navigating ambiguity are becoming even more valuable. Vella proposes a pendulum metaphor: swinging intentionally between writing code directly, orchestrating AI, and blending both. In her view, AI isn&amp;rsquo;t taking the job away so much as giving engineers a chance to reclaim parts of the role that were gradually carved off to other specialists—from understanding user needs and business impact to system design and operations.&lt;/p&gt;
&lt;h2 id="revenge-of-the-junior-developer"&gt;&lt;a href="https://sourcegraph.com/blog/revenge-of-the-junior-developer" rel="noopener noreferrer"&gt;Revenge of the junior developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sourcegraph&amp;rsquo;s Steve Yegge argues that software development is passing through six overlapping waves: traditional programming (2022), completions-based coding (2023), chat-based coding (2024), coding agents (first half of 2025), agent clusters (second half of 2025), and agent fleets (2026). In his view, &amp;ldquo;vibe coding&amp;rdquo; means letting an LLM write code, feeding the results back in, and iterating in a continuous loop—a workflow that will persist across all these waves. Coding agents like Claude Code or Aider can already read tickets, track down bugs, propose fixes, and write tests, though they still need tasks broken down into small pieces and close supervision. He estimates a single agent costs roughly $10–$12 per hour, meaning companies should budget significantly more LLM spend per developer as engineers start running multiple agents in parallel.&lt;/p&gt;
&lt;p&gt;The &amp;ldquo;revenge&amp;rdquo; comes at the end: contrary to his earlier essay &amp;ldquo;The Death of the Junior Developer,&amp;rdquo; junior developers are adopting AI far faster than many senior developers, who often resist because they are heavily invested in the status quo and view learning from scratch as a loss of status. His message is blunt: it&amp;rsquo;s not that AI has to prove it&amp;rsquo;s better than you—you have to become better with AI. By the end of the year, he predicts software engineering will involve much less manual coding and much more supervising agents, so adapt as early as possible; and if you don&amp;rsquo;t know where to start, ask a junior developer.&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/111cec1b-a195-4ff5-963c-714ceecd01ab_1280x1664.gif" alt="How does SSO Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b415d54d-0dbd-428d-a09c-3de0332c0f71_1280x1502.gif" alt="How Java Virtual Threads Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/8ef255cc-ebbb-4710-9faf-f366274a2bef_1280x1373.gif" alt="Memcached vs Redis"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2370fff4-b515-484e-a081-4ce73b2c62c2_1280x1566.gif" alt="The Shopify Tech Stack"&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=eHEHE2fpnWQ" rel="noopener noreferrer"&gt;What Are AI Agents Really About?&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 #7</title><link>https://miti99.com/en/post/2025/03/16/</link><pubDate>Sun, 16 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #7.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-llm-curve-of-impact-on-software-engineers"&gt;&lt;a href="https://serce.me/posts/2025-02-07-the-llm-curve-of-impact-on-software-engineers" rel="noopener noreferrer"&gt;The LLM Curve of Impact on Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov proposes a hypothesis to explain the sharp divide over how useful LLMs really are: their day-to-day value depends heavily on an engineer&amp;rsquo;s seniority, tracing out a distinct curve. For Junior engineers who are still building their mental models of code, LLMs are a lifesaver when deciphering errors, implementing small features, or upgrading libraries. Yet this is also a danger zone: if they just copy and paste code back and forth without understanding why it works, their fundamental skills can stagnate. Mid-level engineers still write code and pick up new frameworks faster with LLMs, but increasingly run into tasks LLMs can&amp;rsquo;t handle—such as figuring out what a customer actually wants from a vague request, hunting down race conditions in a debugger, or handling a 2 a.m. production outage.&lt;/p&gt;
&lt;p&gt;Under this hypothesis, Senior engineers are the most skeptical group. They already hold the system&amp;rsquo;s architecture in their heads, spend a smaller fraction of their day typing boilerplate, and focus on work—roadmapping, debugging gnarly non-reproducible issues, writing design docs—that depends on deep organizational and system context the LLM doesn&amp;rsquo;t have; the more specialized the domain, the sharper the disillusionment. At the Staff+ level, however, the curve bends back up: their job often involves prototyping to blaze trails for other teams, and LLMs drastically speed up building proofs of concept, while their deep expertise lets them immediately spot and untangle whatever corners the model paints itself into. Understanding this curve, the author suggests, builds empathy: the skeptics and the enthusiasts are simply doing very different jobs.&lt;/p&gt;
&lt;h2 id="you-are-using-cursor-ai-incorrectly"&gt;&lt;a href="https://ghuntley.com/stdlib/" rel="noopener noreferrer"&gt;You are using Cursor AI incorrectly&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Geoffrey Huntley argues that most engineers—from juniors to principals—are using Cursor the wrong way: treating it as a Google replacement, writing bare-bones prompts like &amp;ldquo;implement XYZ,&amp;rdquo; using it as a text editor rather than an autonomous agent, and failing to realize that you can &amp;ldquo;program&amp;rdquo; the probability distribution of an LLM&amp;rsquo;s output. His solution is to build a personal &amp;ldquo;stdlib&amp;rdquo; (standard library) of thousands of rules stored in &lt;code&gt;.cursor/rules/&lt;/code&gt;, where each rule is a structured &lt;code&gt;.mdc&lt;/code&gt; file defining filters and actions, named with a consistent convention, and composed together like Unix pipes.&lt;/p&gt;
&lt;p&gt;With these rules in place, you can shape Cursor&amp;rsquo;s behavior permanently: when Cursor kept suggesting Bazel commands even though the author wanted Nix exclusively, he wrote a &lt;code&gt;no_bazel&lt;/code&gt; rule to banish Bazel suggestions altogether. Rules also automate development workflows, such as automatically inserting license headers into new files or committing changes once a task is complete. By the author&amp;rsquo;s estimate, current LLMs are only about 45% accurate out of the box and need constant steering, so continuously curating and refining your rule library is the key to getting real leverage out of Cursor.&lt;/p&gt;
&lt;h2 id="how-do-you-spend-your-time"&gt;&lt;a href="https://brooker.co.za/blog/2024/02/06/time.html" rel="noopener noreferrer"&gt;How Do You Spend Your Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker writes for engineers who feel constantly busy and get plenty done, yet worry they aren&amp;rsquo;t spending their time on the highest-value work for their team and projects. His approach is to set an explicit &amp;ldquo;time budget&amp;rdquo;: pick five or six broad categories of work along with a target percentage of time for each, stay flexible week to week while holding the line over the long run, and review the breakdown periodically with your manager. The act of writing the budget down is the most valuable part, because it forces you to think hard about what success actually looks like in your role. His own buckets include individual technical work (writing, reading, and reviewing code, debugging, design docs), mentoring and teaching, long-term strategy, day-to-day operational rhythm, learning (reading papers, prototyping algorithms), and talking with customers. The exact split matters less than doing the exercise deliberately.&lt;/p&gt;
&lt;p&gt;Sticking to a time budget requires learning to say &amp;ldquo;no.&amp;rdquo; Brooker warns against several traps: chasing high-visibility shiny objects or hype, getting sucked into urgent but low-importance chores, and letting your calendar run away from you—like a senior engineer sitting in 20 hours of meetings a week where nobody sees him contributing much, simply because everyone assumes someone else invited him for a good reason. He applies this same lens at the organizational level and borrows the economics concept of &amp;ldquo;revealed preference&amp;rdquo;: how we actually spend our hours reveals our true priorities, just like claiming you love salad while ordering a burger every day.&lt;/p&gt;
&lt;h2 id="we-are-destroying-software"&gt;&lt;a href="https://antirez.com/news/145" rel="noopener noreferrer"&gt;We are destroying software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a short, manifesto-style post, Redis creator Salvatore Sanfilippo (antirez) lists the ways we are collectively &amp;ldquo;destroying&amp;rdquo; software: piling on features and premature optimizations without weighing their complexity cost; adopting convoluted build systems; assembling absurd dependency chains that leave everything bloated and fragile; telling junior programmers &amp;ldquo;don&amp;rsquo;t reinvent the wheel&amp;rdquo; when reinventing the wheel is precisely how you learn how wheels work—and the first step toward inventing better ones; abandoning API backward compatibility; pushing rewrites of battle-tested code that already works; and chasing every new language, paradigm, and framework fad.&lt;/p&gt;
&lt;p&gt;He also criticizes the habit of underestimating the cost of wrestling with sprawling third-party libraries compared to writing a focused solution yourself, assuming generic industry standards are always better than custom-fit designs, dismissing code comments as useless, and treating software as a purely mechanical engineering discipline. We build systems that cannot &amp;ldquo;scale down&amp;rdquo;—where simple things ought to remain simple—and optimize for coding velocity over design quality. The end result, he warns, is a field stripped of the joy of hacking.&lt;/p&gt;
&lt;h2 id="nontraditional-red-teams"&gt;&lt;a href="https://zachholman.com/posts/red-teams" rel="noopener noreferrer"&gt;Nontraditional Red Teams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Former GitHub engineer Zach Holman expands the concept of a &amp;ldquo;red team&amp;rdquo; (adversarial testers who probe a system for weaknesses) beyond cybersecurity to three everyday roles every product team should have. First is the person who checks whether a new graphic or logo accidentally looks like genital or NSFW imagery: GitHub once came dangerously close to printing its very first highway billboard with an illustration that looked uncannily like the infamous &amp;ldquo;goatse&amp;rdquo; shock image, even after dozens of employees had signed off on it. After that near miss, major design launches at GitHub included a dedicated review step asking how a visual might be misread, mocked, or abused out of context. Second is the ad-blocker user, who speaks up whenever a site breaks navigation simply because a tracking script or HTML snippet got blocked—one of the most frustrating experiences on the modern web.&lt;/p&gt;
&lt;p&gt;Third is the password-manager user. Holman vents about how many teams botch even the most basic login forms with custom inputs that prevent 1Password and similar tools from autofilling credentials. None of these are fatal showstoppers since determined users will eventually work around them, he notes, but they are completely avoidable self-inflicted wounds. When a team is heads-down shipping new features, it&amp;rsquo;s easy to miss these rough edges—which is why having an adversarial &amp;ldquo;red team&amp;rdquo; look at the product with fresh, skeptical eyes pays off.&lt;/p&gt;
&lt;h2 id="ai-or-die"&gt;&lt;a href="https://www.rkg.blog/ai-or-die.php" rel="noopener noreferrer"&gt;AI or Die&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ravi Gupta (RKG) opens with Anthropic CEO Dario Amodei&amp;rsquo;s prediction that as early as 2026 we could see AI models smarter than a Nobel Prize winner across most disciplines, capable of autonomously executing multi-day tasks and running millions of instances in parallel at 10x to 100x human speed—&amp;ldquo;a country of geniuses in a datacenter.&amp;rdquo; Gupta asks: is your company ready to harness that capability, or compete against companies that do? Even today&amp;rsquo;s models can already perform a substantial share of economically valuable work, yet most people barely scratch the surface because they lack ambition, lack the patience to supply rich context, and lack clear thinking and communication.&lt;/p&gt;
&lt;p&gt;To prepare, RKG recommends dedicating a full week to studying what AI can do today and where it is heading; tasking a tiny group to build an &amp;ldquo;AI-native&amp;rdquo; version of your product with a team 10x to 100x smaller; accepting that customers will soon demand dramatically better products at a fraction of the price; going &amp;ldquo;AI-first&amp;rdquo; with the same urgency Facebook once brought to mobile; and auditing every role in the organization to understand who will be supercharged by AI and which functions will be replaced. This isn&amp;rsquo;t an incremental tweak, he argues, but a full-scale &amp;ldquo;refounding&amp;rdquo; of the company—harder the larger and more successful you already are, yet essential to meet a future where, as Sam Altman put it, &amp;ldquo;maybe everyone on earth will be able to accomplish more than the most impactful person can today.&amp;rdquo;&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 #5</title><link>https://miti99.com/en/post/2025/03/04/</link><pubDate>Tue, 04 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/04/</guid><description>&lt;i&gt;
Hello everyone, MiTi was a bit lazy last weekend and didn't put out a post. Enjoy Newsletter #5!
&lt;/i&gt;
&lt;h2 id="5-advanced-java-reflection-techniques-for-dynamic-programming"&gt;&lt;a href="https://dev.to/nithinbharathwaj/5-advanced-java-reflection-techniques-for-dynamic-programming-4ph1" rel="noopener noreferrer"&gt;5 Advanced Java Reflection Techniques for Dynamic Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article introduces five advanced techniques centered around Java&amp;rsquo;s Reflection API, the toolkit for inspecting and modifying the structure and behavior of classes, interfaces, and objects at runtime. The first technique is accessing private members: retrieving a &lt;code&gt;Field&lt;/code&gt; or &lt;code&gt;Method&lt;/code&gt; via &lt;code&gt;getDeclaredField()&lt;/code&gt;/&lt;code&gt;getDeclaredMethod()&lt;/code&gt; and calling &lt;code&gt;setAccessible(true)&lt;/code&gt; to bypass access checks—handy for testing or working with legacy code, though it breaks encapsulation (and is subject to Java 9+ module system restrictions). The second is dynamic object instantiation from a class name known only at runtime using &lt;code&gt;Class.forName()&lt;/code&gt; and a matching constructor, which forms the backbone of plugin architectures in the spirit of the Open-Closed Principle. The third combines custom annotations with reflection to attach metadata to code and process it at runtime—for instance, logging every method invocation—which is how frameworks implement validation, dependency injection, and ORMs. The fourth uses &lt;code&gt;java.lang.reflect.Proxy&lt;/code&gt; to create dynamic proxies for interfaces, weaving in cross-cutting concerns like logging, transaction management, or access control without modifying the target class. The fifth covers runtime bytecode manipulation with libraries like ByteBuddy (outside the standard Reflection API), generating subclasses that intercept method calls on concrete classes as well as interfaces.&lt;/p&gt;
&lt;p&gt;While the examples illustrate how to build extensible plugins, process metadata, and layer on behaviors like logging, there are important caveats: &lt;code&gt;setAccessible(true)&lt;/code&gt; is still constrained by the Java module system, so it cannot guarantee access to every private member; annotations do not intercept calls on their own unless reflective code explicitly inspects them and invokes the target method; JDK &lt;code&gt;Proxy&lt;/code&gt; only works with interfaces; and the ByteBuddy example works by subclassing and intercepting overridable methods. These mechanisms are powerful when dynamic flexibility is needed, but their impact on encapsulation, maintainability, and runtime performance must be weighed carefully.&lt;/p&gt;
&lt;h2 id="mistakes-you-apparently-just-have-to-make-yourself"&gt;&lt;a href="https://medium.com/@mcfunley/mistakes-you-apparently-just-have-to-make-yourself-cc2dd2bfc25c" rel="noopener noreferrer"&gt;Mistakes You Apparently Just Have to Make Yourself&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan McKinley compiles a list of mistakes he calls &amp;ldquo;non-transferable knowledge&amp;rdquo;: no matter how many times seasoned engineers warn you against them, people apparently still have to touch the hot stove themselves to believe it burns. The list hits on classic industry tropes: the legacy codebase is such a mess that we have to rewrite it from scratch; our software is hard to manage, so adding operational complexity will somehow make it easier; our problem is completely novel, so we must adopt bleeding-edge technology; adding network hops will magically make the system faster; running a production system is just like maintaining an open-source project; writing a thin wrapper around a CLI tool adds real value; coding is the bulk of the work; functional tests are all the testing you need; deploying directly from version control is fine; logical separation requires physical separation; bureaucracy solves everything—or solves nothing; and if two teams use the same noun, they should share the same code.&lt;/p&gt;
&lt;p&gt;The final item is self-deprecating: everyone thinks they are the first person to make all 13 mistakes and that the author is writing specifically about them. The post wraps up with a tongue-in-cheek plug for the author&amp;rsquo;s startup, Skyliner, pitching it as a &amp;ldquo;straitjacket&amp;rdquo; to keep you from hurting yourself. For newer engineers, it&amp;rsquo;s a list worth revisiting whenever you&amp;rsquo;re about to make a major architectural bet.&lt;/p&gt;
&lt;h2 id="service-reliability-mathematics"&gt;&lt;a href="https://addyosmani.com/blog/service-reliability/" rel="noopener noreferrer"&gt;Service Reliability Mathematics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that service reliability is too often reduced to a single uptime percentage, when reality is far more nuanced. Even with the exact same total annual downtime, a single 8-hour outage has a very different business impact than 480 one-minute blips, and five minutes of downtime during peak traffic can hurt more than an hour in the middle of the night. Each additional &amp;ldquo;nine&amp;rdquo; of availability demands exponentially more engineering effort and operational complexity: at 99.9% (about 8 hours 46 minutes of downtime per year), a single-region deployment with basic failover may suffice; reaching 99.99% typically requires multi-region active-active or automated failover; and 99.999% and beyond demands redundancy at every layer with real-time monitoring. These percentages also quietly assume that failures are uniformly distributed, independent, and immediately detected, while ignoring partial degradation and cascading failures. A service responding in 500ms instead of 5ms may still count as &amp;ldquo;up,&amp;rdquo; yet be practically unusable.&lt;/p&gt;
&lt;p&gt;Pursuing higher reliability always involves trade-offs between feature velocity and stability, infrastructure cost and redundancy, and on-call burnout for the team. Instead of blindly chasing extra nines, engineers should ask which failure modes actually hurt the business; modern practice favors error budgets, SLOs (Service Level Objectives), and user-centric telemetry to deliver dependable value while keeping engineering pace sustainable.&lt;/p&gt;
&lt;h2 id="how-to-write-a-good-design-document"&gt;&lt;del&gt;&lt;a href="https://grantslatton.com/how-to-design-document" rel="noopener noreferrer"&gt;How to write a good design document&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;The article &amp;ldquo;How to Design Document&amp;rdquo; offers practical advice on writing effective design documents. According to the author, a design document is a technical report that outlines the implementation strategy for a system within the context of trade-offs and constraints. Its primary goal is to convince the reader (and most importantly, the author themselves) that the proposed design is optimal given the current situation.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author compares writing a design document to writing a mathematical proof. To achieve maximum effectiveness, it requires strong organization, much like organizing code. Writers should avoid creating &amp;ldquo;spaghetti design docs&amp;rdquo; by ensuring every sentence connects logically and is easy to follow. The goal is to never surprise the reader, making the solution feel obvious even when it required complex thinking to reach.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The post also emphasizes the importance of understanding the reader&amp;rsquo;s mindset and anticipating potential objections. Furthermore, writers should edit ruthlessly to remove unnecessary words, because the reader&amp;rsquo;s attention is a scarce resource. The author encourages practicing by critiquing other documents and distilling complex ideas into concise tweets.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Finally, the article suggests structuring documents into bullet points that can each be summarized in a single sentence and using footnotes for complex tangents so they don&amp;rsquo;t disrupt the main flow of the document.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="picking-your-battles-when-you-are-hyper-rational"&gt;&lt;a href="https://newsletter.weskao.com/p/picking-your-battles-hyper-rational" rel="noopener noreferrer"&gt;Picking your battles when you are hyper-rational&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao highlights a common habit among hyper-rational people: getting so caught up in proving they are &amp;ldquo;technically correct&amp;rdquo; that they sacrifice practical effectiveness—winning a minor skirmish while losing the war. She illustrates this with two emails she almost sent. In the first example, a recruiter asked to chat &amp;ldquo;this morning&amp;rdquo; when it was already nearly 1:00 PM in Wes&amp;rsquo;s time zone; instead of lecturing on all the ways &amp;ldquo;this morning&amp;rdquo; could be interpreted across time zones, she simply confirmed the time zone and offered a few open slots to lock in the meeting quickly. In the second, a client&amp;rsquo;s finance team told her she didn&amp;rsquo;t need to fill out a vendor onboarding form even though their own billing system had just emailed her demanding it; she nearly wrote a multi-paragraph explanation defending why she had asked, but caught herself and sent a one-line &amp;ldquo;thanks for clarifying.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The lesson is to resist the urge to prove you noticed every nuance or to nitpick someone else&amp;rsquo;s phrasing, which wastes time and makes you look difficult to work with. Before sending a corrective explanation, ask yourself: does this move us closer to the goal, does it actually help the recipient or just prove I&amp;rsquo;m right about an irrelevant detail, and am I serving the conversation or my own ego? There are times when clarifying a misunderstanding matters, of course, but on the small stuff, it&amp;rsquo;s almost always better to let it go and stay focused on the main objective.&lt;/p&gt;
&lt;h2 id="measuring-programmer-influence-kinda-sorta"&gt;&lt;a href="https://tidyfirst.substack.com/p/measuring-programmer-influence-kinda" rel="noopener noreferrer"&gt;Measuring Programmer Influence, Kinda Sorta&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck asks whether data can tell us who contributes the most on a large engineering team. His blunt answer is no—not if you want certainty—though data can hint at where influence lives. He opens with a clear warning: the first time you tie bonuses, promotions, or layoffs to these metrics is the last time they will ever be trustworthy. Analyzing the Git history of the React repository, he observes that both the number of files created per author and the number of times each file is modified follow a Pareto distribution: most contributors create only a single file, while a small handful create hundreds or thousands. Plotting those two dimensions together—files an author created versus how often other people later modified those files—reveals a clear trend line; the engineers in the upper-right corner, who create foundations that others keep building upon, are strong candidates for high-influence contributors.&lt;/p&gt;
&lt;p&gt;Used well, this kind of analysis helps engineers calibrate themselves against peers, find mentors to learn from, and spot people whose real-world impact exceeds their formal title. Used poorly, it gets weaponized for compensation, quotas, promotions, or stack ranking. The data has obvious blind spots too: many vital contributions never show up in commit graphs, and long-tenured team members naturally accumulate higher numbers. The takeaway: never lose sight of the real goal—making a meaningful impact—and always sanity-check your results, because programming with data is still programming.&lt;/p&gt;
&lt;h2 id="building-personal-software-with-claude"&gt;&lt;a href="https://blog.nelhage.com/post/personal-software-with-claude/" rel="noopener noreferrer"&gt;Building personal software with Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nelson Elhage recounts using Claude to port a bottleneck in Emacs&amp;rsquo;s &lt;code&gt;obsidian.el&lt;/code&gt; package to Rust, speeding it up by more than 1,000x (in one specific benchmark, dropping from 90 seconds to roughly 15ms) while barely writing a line of code himself. The culprit was &lt;code&gt;obsidian-update&lt;/code&gt;, which rescanned his entire note vault in Emacs Lisp and had grown painfully slow. With a single prompt, Claude read roughly 1,000 lines of Elisp, identified the ~200 relevant lines, and wrote a Rust program to extract the note metadata as JSON; the generated Rust code compiled and worked on the first try. Next, Claude wrote the Elisp glue using Emacs&amp;rsquo;s &lt;code&gt;advice&lt;/code&gt; mechanism to patch &lt;code&gt;obsidian.el&lt;/code&gt;, hitting only one minor bug that was fixed in minutes. The entire project took a single afternoon. Even though Elhage works at Anthropic, he had previously thought of Claude mostly as a better Stack Overflow.&lt;/p&gt;
&lt;p&gt;Reflecting on the experience, he draws several conclusions. First, the tooling and UX around LLMs are still lagging behind the raw capabilities of the models themselves. Second, he noticed that he naturally decomposed the problem along clean, easily testable interface boundaries: the human handles system decomposition, while Claude fills in the &amp;ldquo;meat&amp;rdquo; in between. Most importantly, while code is now cheaper than ever to produce, deep understanding, architecture, and good design are only becoming more valuable; writing &amp;ldquo;easy-to-delete&amp;rdquo; code may matter even more when an LLM can regenerate an implementation from scratch on demand. Above all, he rediscovered the joy of building small personal tools now that Claude can shoulder the tedious parts.&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/1112c07d-db40-484e-917b-0071ed7cf354_1280x1532.gif" alt="Git vs GitHub"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5fd8bdda-52dd-454f-be79-ad548f17810b_1280x1557.gif" alt="A Cheatsheet on Database Performance"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/35ae3f82-afa0-47b9-a2a0-58b6c6d8cfb1_1280x1476.gif" alt="18 Common Ports Worth Knowing"&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></channel></rss>