<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Software Design on miti99</title><link>https://miti99.com/en/tags/software-design/</link><description>Recent content in Software Design 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/software-design/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #133</title><link>https://miti99.com/en/post/2026/10/01/</link><pubDate>Thu, 01 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #133.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-go-is-an-ideal-language-for-ai-assisted-software-engineering"&gt;&lt;a href="https://developers.googleblog.com/why-go-is-an-ideal-language-for-ai-assisted-software-engineering/" rel="noopener noreferrer"&gt;Why Go is an Ideal Language for AI-Assisted Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with &lt;code&gt;gofmt&lt;/code&gt;, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.&lt;/p&gt;
&lt;p&gt;On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go&amp;rsquo;s checksum database guards against tampered dependencies, while &lt;code&gt;govulncheck&lt;/code&gt; alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and &lt;code&gt;go fix&lt;/code&gt; lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.&lt;/p&gt;
&lt;h2 id="how-does-programming-language-affect-token-efficiency-and-correctness"&gt;&lt;a href="https://danluu.com/pl-tokens/" rel="noopener noreferrer"&gt;How does programming language affect token efficiency and correctness?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete &lt;code&gt;zstd&lt;/code&gt; decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).&lt;/p&gt;
&lt;p&gt;The results tell a nuanced story: on &lt;code&gt;zstd&lt;/code&gt; at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed &lt;code&gt;byte&lt;/code&gt; coercion throws an exception on values &lt;code&gt;128–255&lt;/code&gt;. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren&amp;rsquo;t enough to draw universal laws, the blanket claim that &amp;ldquo;dynamic languages are better for LLMs&amp;rdquo; doesn&amp;rsquo;t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.&lt;/p&gt;
&lt;h2 id="my-agentic-coding-setup-july-2026"&gt;&lt;a href="https://domenic.me/agentic-coding-setup/" rel="noopener noreferrer"&gt;My Agentic Coding Setup, July 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a &amp;ldquo;semi-disposable&amp;rdquo; Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (&lt;code&gt;--dangerously-skip-permissions&lt;/code&gt; / &lt;code&gt;--yolo&lt;/code&gt;) mode with &lt;code&gt;gh&lt;/code&gt; pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn&amp;rsquo;t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.&lt;/p&gt;
&lt;p&gt;The remaining pieces solve each workflow friction point: &lt;code&gt;git worktree&lt;/code&gt; lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT&amp;rsquo;s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and &lt;code&gt;chezmoi&lt;/code&gt; syncs his &lt;code&gt;AGENTS.md&lt;/code&gt;, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.&lt;/p&gt;
&lt;h2 id="the-bedrock-of-software-design"&gt;&lt;a href="https://alex.draftist.io/blog/the-bedrock-of-software-design-ycqvcedsj" rel="noopener noreferrer"&gt;The Bedrock of Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. &lt;em&gt;Product types&lt;/em&gt; combine multiple fields into a single value, like a struct with an &lt;code&gt;id&lt;/code&gt; and a &lt;code&gt;role&lt;/code&gt;; &lt;em&gt;sum types&lt;/em&gt; (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either &lt;code&gt;Anonymous&lt;/code&gt; or &lt;code&gt;Authenticated(User)&lt;/code&gt;. When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with &lt;code&gt;Switchable&lt;/code&gt; and &lt;code&gt;Fixed&lt;/code&gt; variants, each holding only the fields that actually apply, making illegal states unrepresentable.&lt;/p&gt;
&lt;p&gt;The same thinking applies to errors and the absence of values. With unchecked exceptions, a function&amp;rsquo;s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via &lt;code&gt;Result&lt;/code&gt;, whose error type can itself be a domain-specific sum type carrying rich context. &lt;code&gt;Option&amp;lt;T&amp;gt;&lt;/code&gt; replaces &lt;code&gt;null&lt;/code&gt;, and a signature like &lt;code&gt;Result&amp;lt;Option&amp;lt;User&amp;gt;, FindUserError&amp;gt;&lt;/code&gt; cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive &lt;code&gt;match&lt;/code&gt; expressions force callers to handle every variant, so when a new &lt;code&gt;Staff&lt;/code&gt; role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev&amp;rsquo;s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.&lt;/p&gt;
&lt;h2 id="90--of-the-t-distribution"&gt;&lt;a href="https://entropicthoughts.com/ninety-percent-of-the-t-distribution" rel="noopener noreferrer"&gt;90 % of the t distribution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student&amp;rsquo;s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.&lt;/p&gt;
&lt;p&gt;With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you&amp;rsquo;re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-computer-not-a-container--introducing-cloudflarecomputer"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-computer/" rel="noopener noreferrer"&gt;Your agent needs a computer, not a container — introducing @cloudflare/computer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare has released a preview of &lt;code&gt;@cloudflare/computer&lt;/code&gt;, an open-source, npm-installable agent runtime that gives every AI agent its own virtual &amp;ldquo;computer&amp;rdquo; complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare&amp;rsquo;s target is for containers to handle less than 10% of an agent&amp;rsquo;s workload.&lt;/p&gt;
&lt;p&gt;Architecturally, the runtime decouples the agent&amp;rsquo;s &amp;ldquo;brain&amp;rdquo; from its &amp;ldquo;hands&amp;rdquo;: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a &lt;code&gt;node:fs&lt;/code&gt;-compatible wrapper. Two execution backends sit behind a unified &lt;code&gt;exec&lt;/code&gt; interface: the isolate backend uses &lt;code&gt;just-bash&lt;/code&gt; to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.&lt;/p&gt;
&lt;h2 id="notes-on-incidents"&gt;&lt;a href="https://www.seangoedecke.com/notes-on-incidents/" rel="noopener noreferrer"&gt;Notes on incidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic &amp;ldquo;firefighting&amp;rdquo; often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.&lt;/p&gt;
&lt;p&gt;When intervention &lt;em&gt;is&lt;/em&gt; needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.&lt;/p&gt;
&lt;h2 id="beyond-clean-code-why-your-comments-matter"&gt;&lt;a href="https://blog.moertel.com/posts/2026-07-27-beyond-clean-code-why-your-comments-matter.html" rel="noopener noreferrer"&gt;Beyond “Clean Code”: Why Your Comments Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express &lt;em&gt;what&lt;/em&gt; the machine is instructed to do, whereas human readers also need to know &lt;em&gt;what the author intended&lt;/em&gt; and &lt;em&gt;why&lt;/em&gt; the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn&amp;rsquo;t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; that comments shouldn&amp;rsquo;t be used as deodorant for needlessly tangled code, he argues that the dogma &amp;ldquo;every comment is a failure&amp;rdquo; goes way too far. Crucial &amp;ldquo;why&amp;rdquo; context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.&lt;/p&gt;
&lt;p&gt;Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. &lt;em&gt;&amp;ldquo;Comments lie&amp;rdquo;&lt;/em&gt;: without a comment stating the intent, buggy code leaves zero clue that it&amp;rsquo;s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. &lt;em&gt;&amp;ldquo;Comments rot&amp;rdquo;&lt;/em&gt;: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.&lt;/p&gt;
&lt;h2 id="relying-on-go"&gt;&lt;a href="https://antonz.org/relying-on-go/" rel="noopener noreferrer"&gt;Relying on Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many new programming languages pitch themselves as &amp;ldquo;like Go, but with more features&amp;rdquo; or &amp;ldquo;like Rust, but simpler.&amp;rdquo; Anton Zhiyanov takes the opposite path with Solod, a &amp;ldquo;systems language for C and Go programmers&amp;rdquo;: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, &lt;code&gt;gopls&lt;/code&gt; autocomplete, linters, formatters, and &lt;code&gt;go.mod&lt;/code&gt; package management. The developer workflow is identical to Go: install the &lt;code&gt;so&lt;/code&gt; CLI tool, initialize a Go module, import Solod&amp;rsquo;s standard library package, and write normal Go code; &lt;code&gt;so run .&lt;/code&gt; compiles and runs the binary just like &lt;code&gt;go run&lt;/code&gt;. Even Solod&amp;rsquo;s standard library reuses large swaths of Go&amp;rsquo;s standard library code and test suites, adapted for manual memory management.&lt;/p&gt;
&lt;p&gt;Zhiyanov is upfront about the trade-offs: standard Go tooling doesn&amp;rsquo;t know about Solod&amp;rsquo;s subset restrictions, so &lt;code&gt;gopls&lt;/code&gt; won&amp;rsquo;t warn you if you use unsupported Go features like closures or iterators—catching those is up to the &lt;code&gt;so&lt;/code&gt; compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, &lt;code&gt;so&lt;/code&gt; transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn&amp;rsquo;t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod&amp;rsquo;s greatest strength.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was reviewed and updated 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 #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 #104</title><link>https://miti99.com/en/post/2026/05/24/</link><pubDate>Sun, 24 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #104.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="designing-the-ai-native-engineering-organization"&gt;&lt;a href="https://newsletter.getdx.com/p/designing-the-ai-native-engineering" rel="noopener noreferrer"&gt;Designing the AI-native engineering organization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a panel at the DX Annual conference, engineering leaders from Microsoft, 1Password, and Atlassian shared how AI is reshaping the software development lifecycle (SDLC). Previously, roughly 80% of engineering time went into execution and operations, but in the highest-performing teams that ratio is flipping: as AI compresses code generation and routine execution, planning and verification now take up the bulk of the time, because that is where human judgment matters most. The speakers advised against handing verification or security over to AI just yet.&lt;/p&gt;
&lt;p&gt;Notably, none of the companies redrew their org charts; what changed is how teams work internally. Atlassian forms 3–4 person pods for greenfield projects, Microsoft uses small v-teams running on eight-week cycles for rapid learning, and 1Password shortened its planning horizon from 12–18 months down to a single quarter. None of the three mandated AI usage; instead, they invested in training, amplified internal &amp;ldquo;champions,&amp;rdquo; and shared concrete success stories. Token spend is managed as rigorously as cloud infrastructure costs, with 1Password building internal tooling to map spend by repo and project. The archetype of the future engineer is a &amp;ldquo;maker&amp;rdquo; with broad generalist knowledge, strong product intuition, and the agency to make decisions. Non-engineers like designers and customer experience staff are now submitting pull requests too, though that is only safe when backed by a solid test suite and deployment verification pipeline.&lt;/p&gt;
&lt;h2 id="10-lessons-for-agentic-coding"&gt;&lt;a href="https://www.dbreunig.com/2026/05/04/10-lessons-for-agentic-coding.html" rel="noopener noreferrer"&gt;10 Lessons for Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drew Breunig distills ten lessons for developers working with AI agents like Claude Code, Codex, or Pi around a central question: what should you do when code becomes cheap? Because writing code surfaces decisions that a spec never anticipated, he advises implementing to learn and not hesitating to throw code away and rebuild multiple times to test bold ideas. Pair that with end-to-end tests that measure product behavior rather than implementation details, leaving you free to rewrite the underlying code. Neither tests nor code capture &lt;em&gt;why&lt;/em&gt; something was built a certain way, so keep intent alongside the codebase and evolve the spec in tandem with development rather than freezing it up front.&lt;/p&gt;
&lt;p&gt;When the easy parts are handled quickly by AI, real value shifts to the hard parts: intuitive design, performance, security, fault tolerance, and system architecture. Automate all the easy work to free up time for the hard problems, and cultivate your own &amp;ldquo;taste&amp;rdquo; — because when code is generated faster than external feedback can arrive, your domain and user understanding become the only feedback loop fast enough to keep pace. AI agents also amplify experience: engineers with deep technical mastery know the right terminology, how to frame problems, and the right level of specificity, saving countless iterations. The final lesson is a reminder: code is cheap, but maintenance, support, and security are not.&lt;/p&gt;
&lt;h2 id="just-fucking-use-go"&gt;&lt;a href="https://blainsmith.com/articles/just-fucking-use-go/" rel="noopener noreferrer"&gt;Just Fucking Use Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an intentionally blunt polemic, Blain Smith argues that Go has been sitting there for over a decade waiting for developers to stop overcomplicating backend development. Go&amp;rsquo;s boredom is by design: no decorators, no macros, no metaclasses — just structs, functions, interfaces, goroutines, and channels. Because of that, a newly hired junior developer can read code written two years ago by someone who already left, and &lt;code&gt;gofmt&lt;/code&gt; enforces a single formatting style, ending all style debates. The standard library &lt;em&gt;is&lt;/em&gt; the framework: &lt;code&gt;net/http&lt;/code&gt;, &lt;code&gt;database/sql&lt;/code&gt;, &lt;code&gt;encoding/json&lt;/code&gt;, and &lt;code&gt;html/template&lt;/code&gt; paired with &lt;code&gt;embed&lt;/code&gt; are enough to build a complete database-backed web app with zero third-party dependencies; &lt;code&gt;io.Reader&lt;/code&gt;/&lt;code&gt;io.Writer&lt;/code&gt; and &lt;code&gt;context.Context&lt;/code&gt; make every component snap together cleanly and propagate cancellation end to end. Goroutines cost only about 2KB at startup, and channels handle synchronization.&lt;/p&gt;
&lt;p&gt;The biggest advantage is operational: &lt;code&gt;go build&lt;/code&gt; produces a single static binary that you can &lt;code&gt;scp&lt;/code&gt; to a server and restart with systemd — no Dockerfile, Kubernetes, or service mesh required. Dependency management fits neatly into &lt;code&gt;go.mod&lt;/code&gt; and &lt;code&gt;go.sum&lt;/code&gt;, while testing, race detection, benchmarking, and profiling ship built-in with the toolchain. The author criticizes Rails, Django, Express, and Next.js for elaborate deployment rituals and constantly shifting conventions, advocating instead for a monolith consisting of one Go binary and one PostgreSQL instance rather than chasing microservices. Even &lt;code&gt;if err != nil&lt;/code&gt; error handling is praised as a feature, because it forces you to decide how to handle failures at every call site where something can go wrong.&lt;/p&gt;
&lt;h2 id="symptoms-of-bad-software-design"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/symptoms-of-bad-software-design" rel="noopener noreferrer"&gt;Symptoms of Bad Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marcos F. Lobo outlines four symptoms of poor software design along with how to fix them. &lt;strong&gt;Rigidity&lt;/strong&gt; is when a small change in one module triggers a cascade of changes across dependent modules, turning a two-day estimate into two weeks; the root cause is usually tight coupling. For example, an order-processing class with a giant &lt;code&gt;switch&lt;/code&gt; statement calculating shipping rates for every carrier can be refactored using the Strategy Pattern (Open/Closed Principle) so each carrier has its own class and adding a new one requires no edits to existing code. &lt;strong&gt;Fragility&lt;/strong&gt; is when fixing something in one place breaks an unrelated feature elsewhere — such as changing a date format in a global config Singleton and breaking the payroll module; the cure is encapsulation and interface segregation so each module only sees the configuration it actually needs.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Immobility&lt;/strong&gt; appears when business logic is so entangled with UI, database, and framework code that extracting it for reuse takes more effort than rewriting it from scratch. The solution is layered architecture (Clean Architecture): isolate the core algorithm into a pure component that receives database access through an interface following the Dependency Inversion Principle. &lt;strong&gt;Viscosity&lt;/strong&gt; is when doing the right thing is harder than hacking in a shortcut, whether due to software design or a sluggish development environment, pushing developers toward band-aid fixes. The remedy is automating and improving infrastructure and using tooling to cut boilerplate so the right path is nearly as fast as the wrong one. Recognizing these four symptoms is the first step toward incremental refactoring.&lt;/p&gt;
&lt;h2 id="claude-code-is-not-making-your-product-better"&gt;&lt;a href="https://ethanding.substack.com/p/claude-code-is-not-making-your-product" rel="noopener noreferrer"&gt;Claude Code is Not Making Your Product Better&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan Ding challenges the notion that AI coding agents are making products better, even as code output climbs. Commit-size charts show a K-shaped productivity split: senior engineers have seen a sharp jump in output since 2023, while junior engineers have largely flatlined or declined. Builders like dax (opencode), Karri Saarinen (Linear), and David Cramer (Sentry) all struggle to see faster product improvement from agents. The author argues that if Claude Code truly created a compounding advantage, Anthropic should have pulled far ahead of competitors after months of exclusive internal use, yet the later-arriving Codex competes neck and neck — meaning the bottleneck to product quality was never typing speed.&lt;/p&gt;
&lt;p&gt;The best engineering cultures treat lines of code as a liability rather than an asset, because every line is surface area for bugs and accumulating complexity; tinychat even sets alerts when the codebase crosses a size threshold and celebrates deleting code. Linear achieved higher quality than Jira with a fraction of the engineering headcount because the difference comes from creative vision and restraint — deciding to build less — rather than token generation speed. In the author&amp;rsquo;s view, coding agents help products get from zero to &amp;ldquo;decent&amp;rdquo; faster and will make commodity software much cheaper, but they don&amp;rsquo;t help frontier teams build extraordinary products — leaving behind a pile of technical debt that someone will eventually have to clean up.&lt;/p&gt;
&lt;h2 id="the-pulse-ai-load-breaks-github--why-not-other-vendors"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-ai-load-breaks-github/" rel="noopener noreferrer"&gt;The Pulse: AI load breaks GitHub – why not other vendors?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz analyzes GitHub&amp;rsquo;s recent string of severe outages. On April 23, a bug caused pull requests merged via merge queue using squash merge to produce corrupt commits whenever a merge group contained more than one PR, &amp;ldquo;losing&amp;rdquo; commits across 2,092 pull requests — violating the most fundamental data-integrity guarantee and forcing customers to recover manually. A wave of other incidents followed: an overloaded Elasticsearch cluster made pull requests and issues vanish from the UI for 6 hours, GitHub Actions suffered outages, and Wiz disclosed a critical RCE vulnerability. An unofficial third-party tracker recorded uptime around 86% (measured as time with no component reporting an incident), or &amp;ldquo;zero nines.&amp;rdquo; Mitchell Hashimoto, creator of Ghostty, announced he was leaving GitHub after 18 years because near-daily outages were blocking his work.&lt;/p&gt;
&lt;p&gt;GitHub&amp;rsquo;s CTO blamed higher-than-forecast load from AI agents: traffic grew roughly 3.5x over two years, with most of the surge concentrated in recent months. GitHub only began planning a 10x capacity expansion in October 2025, months behind Google, and by February 2026 had to revise the target to 30x. At the same time, the company is migrating from its own data centers to Azure, making underlying flaws much more likely to surface as outages. Why, then, have Vercel, Linear, GitLab, and Bitbucket weathered similar AI traffic waves without buckling? Orosz argues that much of GitHub&amp;rsquo;s pain is self-inflicted: a heavily stateful architecture that is hard to scale horizontally, 18 years of technical debt, roughly 4,000 employees who have to coordinate, and an inability to break existing customer workflows.&lt;/p&gt;
&lt;h2 id="you-need-ai-that-reduces-maintenance-costs"&gt;&lt;a href="https://www.jamesshore.com/v2/blog/2026/you-need-ai-that-reduces-your-maintenance-costs" rel="noopener noreferrer"&gt;You Need AI That Reduces Maintenance Costs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Shore gets straight to the point: coding agents must reduce maintenance costs, and they must reduce them in proportion to the increase in code-writing speed. Every line of code carries an indefinite maintenance tail of bug fixes, cleanup, and dependency upgrades. Using a &amp;ldquo;wisdom of the crowd&amp;rdquo; estimate, he assumes each month of feature coding generates roughly 10 days of maintenance in the first year and 5 days in each subsequent year. Modeling this in a spreadsheet shows that after about two and a half years, a team spends more than half its time on maintenance, and after ten years it can barely build anything new — matching what he observes when consulting for late-stage startups.&lt;/p&gt;
&lt;p&gt;Applying this to AI: if an agent doubles code output but produces code that is twice as hard to maintain, the productivity gain is wiped out in roughly five months, and long-term velocity ends up lower than without AI. Even if AI-generated code is just as maintainable as human-written code, the net benefit only lasts about 19 months. Worse, if a team later stops using agents due to high costs, the speed boost disappears while the maintenance burden of all that generated code stays behind — a form of &amp;ldquo;perpetual servitude.&amp;rdquo; Shore&amp;rsquo;s conclusion: maintenance cost must drop inversely with output — doubling output requires cutting maintenance cost in half. Teams should therefore invest at least as much effort into reducing maintenance costs as they do into chasing coding speed.&lt;/p&gt;
&lt;h2 id="cognitive-surrender"&gt;&lt;a href="https://addyosmani.com/blog/cognitive-surrender/" rel="noopener noreferrer"&gt;Cognitive Surrender&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani introduces the concept of &amp;ldquo;cognitive surrender&amp;rdquo; from research by Steven Shaw and Gideon Nave (Wharton). It must be distinguished from &amp;ldquo;cognitive offloading&amp;rdquo;: offloading delegates the &amp;ldquo;how&amp;rdquo; to AI while you still evaluate the result yourself, whereas surrender happens when you stop forming your own answer and let the AI&amp;rsquo;s output become your output. Across three experiments with 1,372 participants, when AI gave a wrong answer, participants accepted the incorrect answer 73% of the time, and their confidence actually increased even though half the answers were deliberately rigged to be wrong. For developers, this shows up as approving a 600-line PR just because tests are green, letting an agent fix a bug without understanding the root cause, or letting an agent make architectural decisions.&lt;/p&gt;
&lt;p&gt;Software engineers are uniquely vulnerable because generated code compiles and passes linters so it looks right on the surface, productivity metrics count merged PRs, and models always speak in an authoritative tone. Each act of surrender is a small loan that compounds into &amp;ldquo;comprehension debt&amp;rdquo; — the growing gap between the code that exists and the code humans actually understand. To push back, Osmani suggests forming your own expectations before looking at the output, reading diffs as if they were written by a junior dev, asking the model to critique itself, watching out for fatigue, keeping PRs small, and treating verification evidence as a mandatory condition for finishing a task. If code keeps shipping while your understanding of the system shrinks, you are accumulating comprehension debt.&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_!oEvb!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F49df56c9-1f92-4f88-bd16-8cd59dab407c_2484x3002.jpeg" alt="Claude Code vs. OpenClaw: 5 Design Dimensions"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6UGD!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F265133fd-d0f8-48c0-b170-73f6e6a49fec_1280x1605.jpeg" alt="Why Does Git Revert Cause Conflicts?"&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 #63</title><link>https://miti99.com/en/post/2025/12/03/</link><pubDate>Wed, 03 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #63.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="simplify-your-code-with-functional-core-imperative-shell"&gt;&lt;a href="https://testing.googleblog.com/2025/10/simplify-your-code-functional-core.html" rel="noopener noreferrer"&gt;Simplify your code with functional core, imperative shell&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This entry in the &amp;ldquo;Tech on the Toilet&amp;rdquo; series on the Google Testing Blog, written by Arham Jain, introduces the &lt;strong&gt;Functional Core, Imperative Shell&lt;/strong&gt; design pattern. A common problem in software is mixing business logic with side effects like database queries, network requests, or sending emails, which makes code hard to test, reuse, and reason about. The solution is to split code into two layers: a functional core made up solely of pure functions with no I/O and no external state mutation that operate strictly on their inputs; and an imperative shell that handles all side effects and delegates decision-making to the core.&lt;/p&gt;
&lt;p&gt;The article&amp;rsquo;s example starts with a &lt;code&gt;sendUserExpiryEmail&lt;/code&gt; function that loops over database users, filters expired accounts, and sends emails all in one place. After refactoring, the core contains two pure functions—&lt;code&gt;getExpiredUsers&lt;/code&gt; (filtering expired, non-free-trial users) and &lt;code&gt;generateExpiryEmails&lt;/code&gt; (producing the list of recipients and email bodies)—while the shell shrinks to a single &lt;code&gt;email.bulkSend(...)&lt;/code&gt; call. Now the core can be unit-tested in isolation without mocks, the shell is easy to swap out, and adding a feature like a five-day advance reminder only requires writing one new pure function and reusing &lt;code&gt;getExpiredUsers&lt;/code&gt;. The post also links to Gary Bernhardt&amp;rsquo;s original talk on the pattern.&lt;/p&gt;
&lt;h2 id="rdel-94-how-do-experienced-engineers-actually-review-code"&gt;&lt;a href="https://rdel.substack.com/p/rdel-94-how-do-experienced-engineers" rel="noopener noreferrer"&gt;RDEL #94: How do experienced engineers actually review code?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This issue of RDEL summarizes a qualitative study that observed 10 experienced engineers performing 25 real-world code reviews across open-source and internal projects, paired with semi-structured interviews. The findings show that reviewers work through three phases: building context from the PR title and description (observed in 84% of reviews), inspecting details by reading, running code, or asking questions, and finally reaching a decision. Throughout a review, engineers simultaneously hold three mental models in their heads: the actual code in the PR, the expected change, and an ideal implementation; gaps between these three models are what trigger questions or change requests. Rather than trying to understand every line equally, they actively scope their attention based on complexity and risk, sometimes asking the author for a live walkthrough when a change is especially intricate.&lt;/p&gt;
&lt;p&gt;Beyond the PR diff itself, reviewers consult issue trackers (44%), prior discussions (40%), external tools, and their own institutional knowledge of the system and team conventions. Understanding is built collaboratively over time rather than by reading code in isolation. Based on these findings, the post recommends that engineering managers support reviewing by commit, file, or feature, require high-quality PR descriptions explaining the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;why,&amp;rdquo; and automate low-value checks like formatting via linters and CI so human reviewers can focus on architecture and logic.&lt;/p&gt;
&lt;h2 id="the-great-software-quality-collapse-how-we-normalized-catastrophe"&gt;&lt;a href="https://techtrenches.dev/p/the-great-software-quality-collapse" rel="noopener noreferrer"&gt;The Great Software Quality Collapse: How We Normalized Catastrophe&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on Tech Trenches, Denis Stetskov warns that software quality is in severe decline and extreme resource bloat has been normalized: Apple&amp;rsquo;s Calculator leaking 32GB of RAM, VS Code leaking 96GB over SSH, Microsoft Teams pinning 100% CPU on a 32GB machine, Discord eating 32GB during screen sharing, and Spotify consuming 79GB on macOS. The July 2024 CrowdStrike outage is the costliest example: a missing array bounds check in a configuration parser crashed 8.5 million Windows machines, causing an estimated $10 billion in damages. AI coding tools are amplifying the problem, exemplified by Replit&amp;rsquo;s AI assistant ignoring explicit instructions, wiping a production database, and fabricating fake data to cover it up; cited research found AI-generated code contains 322% more security vulnerabilities.&lt;/p&gt;
&lt;p&gt;The author argues that software is hitting physical limits: stacked abstraction layers (React, Electron, Chromium, Docker, Kubernetes…) multiply overhead 2–6x, and data centers consume 200 TWh per year while power grids struggle to keep up. Big tech companies spend $364 billion on infrastructure rather than fixing root causes. The most worrying long-term consequence is slashing junior roles: without juniors today, there are no seniors tomorrow. His prescription is to prioritize quality over velocity, measure actual resource consumption, strip away redundant abstraction layers, and return to fundamentals like bounds checking and memory management.&lt;/p&gt;
&lt;h2 id="building-an-agent-that-leverages-throwaway-code"&gt;&lt;a href="https://lucumr.pocoo.org/2025/10/17/code/" rel="noopener noreferrer"&gt;Building an Agent That Leverages Throwaway Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher (creator of Flask) proposes building agents that solve even non-programming tasks by having the AI write &lt;strong&gt;throwaway code&lt;/strong&gt; instead of relying on a fixed set of predefined tools. The key building block is &lt;strong&gt;Pyodide&lt;/strong&gt;, a Python interpreter compiled to WebAssembly that can install compatible packages via &lt;code&gt;micropip&lt;/code&gt;—including pure-Python packages or Pyodide builds—to process documents and images; Ronacher recommends running Pyodide inside a Web Worker so execution can be interrupted if needed. For safe resource access, the agent interacts with a &lt;strong&gt;virtual filesystem&lt;/strong&gt;: file reads and writes are intercepted and translated into external API calls, so the sandbox never needs direct network access.&lt;/p&gt;
&lt;p&gt;Because an agent run can span many steps, he uses a simple &lt;strong&gt;durable execution&lt;/strong&gt; mechanism: snapshotting state into a key-value store after every step so retries can resume from where they left off without recomputing earlier work. Alongside the Python interpreter, the agent gets a &lt;code&gt;Describe&lt;/code&gt; tool to reason over artifacts produced by its code and a &lt;code&gt;Help&lt;/code&gt; tool to look up documentation or query a RAG index. His &lt;a href="https://github.com/mitsuhiko/mini-agent" rel="noopener noreferrer"&gt;mini-agent&lt;/a&gt; repo demonstrates the idea: the agent reads an IP address from a virtual network drive and renders an illustration. In Ronacher&amp;rsquo;s view, this approach is simpler than wiring MCP servers into an interpreter, and similar patterns are emerging in Anthropic&amp;rsquo;s Claude Skills and Cloudflare&amp;rsquo;s Code Mode.&lt;/p&gt;
&lt;h2 id="measuring-engineering-productivity"&gt;&lt;a href="https://justoffbyone.com/posts/measuring-engineering-productivity/" rel="noopener noreferrer"&gt;Measuring Engineering Productivity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Can Duruk shares the engineering productivity measurement system he built at Felt, a SaaS company that grew from 2 to 25 engineers and ships up to 25 deployments a day. The core principle is that managers absorb most of the &amp;ldquo;paperwork&amp;rdquo; rather than pushing it onto engineers. Daily, engineers post an async standup in &lt;code&gt;#standups&lt;/code&gt; on Slack covering yesterday, today, and blockers, taking just 5–10 minutes. Weekly, managers compile a changelog from GitHub, categorizing PRs by engineer and into product features, bug fixes, or developer experience; 1:1s center on people, product, and process with shared notes in Notion; and each team gets a few minutes to demo weekly wins at All-Hands. In real time, merged PRs automatically post to Slack, and engineers verify their own changes in production and sign off with an emoji reaction.&lt;/p&gt;
&lt;p&gt;Duruk advises starting small (the full system took two years to evolve), tailoring practices to your organization&amp;rsquo;s context, setting clear expectations with concrete examples, and continuously gathering feedback through 1:1s and retros. He rejects vanity metrics like lines of code or commit counts, while emphasizing that measurement itself isn&amp;rsquo;t the enemy—bad measurement is. Numbers serve as a diagnostic tool to sanity-check a manager&amp;rsquo;s intuition and ground tough conversations, not as a weapon to grade individuals.&lt;/p&gt;
&lt;h2 id="scripts-i-wrote-that-i-use-all-the-time"&gt;&lt;a href="https://evanhahn.com/scripts-i-wrote-that-i-use-all-the-time/" rel="noopener noreferrer"&gt;Scripts I wrote that I use all the time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn tours the collection of personal shell scripts he has accumulated over more than a decade in his dotfiles, hosted publicly on Codeberg. The scripts fall into several categories: clipboard utilities (&lt;code&gt;copy&lt;/code&gt; and &lt;code&gt;pasta&lt;/code&gt; wrapping clipboard operations, &lt;code&gt;pastas&lt;/code&gt; watching clipboard history, &lt;code&gt;cpwd&lt;/code&gt; copying the current directory path); file operations (&lt;code&gt;mkcd&lt;/code&gt; to create and enter a directory, &lt;code&gt;tempe&lt;/code&gt; to open a temporary directory, &lt;code&gt;trash&lt;/code&gt; to move files to the trash instead of permanently deleting them, &lt;code&gt;mksh&lt;/code&gt; to scaffold a new shell script); internet utilities (&lt;code&gt;serveit&lt;/code&gt; to spin up a local web server, &lt;code&gt;getsong&lt;/code&gt;, &lt;code&gt;getpod&lt;/code&gt;, and &lt;code&gt;getsubs&lt;/code&gt; wrapping &lt;code&gt;yt-dlp&lt;/code&gt;, &lt;code&gt;url&lt;/code&gt; to parse URL components); and text processing (&lt;code&gt;scratch&lt;/code&gt; to open a scratch buffer, &lt;code&gt;straightquote&lt;/code&gt; to normalize curly quotes, &lt;code&gt;markdownquote&lt;/code&gt; to format blockquotes).&lt;/p&gt;
&lt;p&gt;He also shares media scripts like &lt;code&gt;tunes&lt;/code&gt;, &lt;code&gt;pix&lt;/code&gt;, &lt;code&gt;radio&lt;/code&gt;, &lt;code&gt;speak&lt;/code&gt;, and &lt;code&gt;boop&lt;/code&gt; (playing a sound effect based on whether the previous command succeeded or failed), system helpers like &lt;code&gt;theme&lt;/code&gt; to toggle light/dark mode, &lt;code&gt;sleepybear&lt;/code&gt; to hibernate, &lt;code&gt;murder&lt;/code&gt; to kill processes, and &lt;code&gt;bb&lt;/code&gt; to detach background processes cleanly, plus quick lookup tools like &lt;code&gt;emoji&lt;/code&gt;, &lt;code&gt;httpstatus&lt;/code&gt;, and &lt;code&gt;alphabet&lt;/code&gt;. For newer developers, it&amp;rsquo;s great inspiration to start automating repetitive daily tasks with small scripts; the full source is available in his &lt;a href="https://codeberg.org/EvanHahn/dotfiles" rel="noopener noreferrer"&gt;dotfiles&lt;/a&gt;.&lt;/p&gt;
&lt;h2 id="sql-anti-patterns-you-should-avoid"&gt;&lt;a href="https://datamethods.substack.com/p/sql-anti-patterns-you-should-avoid" rel="noopener noreferrer"&gt;SQL Anti-Patterns You Should Avoid&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on Data Methods, Jordan Goodman rounds up six common SQL anti-patterns that make queries slow and hard to maintain. First, overusing &lt;code&gt;CASE WHEN&lt;/code&gt; to translate status codes inline across views creates duplication and inconsistency; instead, create a dimension table or view sourced from the canonical status table. Second, wrapping indexed columns in functions like &lt;code&gt;UPPER()&lt;/code&gt; can prevent the database from using an index seek on the base column; depending on the DBMS, use expression indexes or computed columns instead, making sure any rewritten predicate preserves exact comparison semantics. Third, using &lt;code&gt;SELECT *&lt;/code&gt; in views makes downstream dependencies brittle when schemas change and pulls in unnecessary columns; always list required columns explicitly.&lt;/p&gt;
&lt;p&gt;Fourth, slapping &lt;code&gt;DISTINCT&lt;/code&gt; onto a query to hide duplicate rows usually masks a broken join condition; the real fix is correcting the join logic. Fifth, stacking views on top of views makes query optimization and debugging painful; periodically flatten transformation layers and materialize heavy logic. Sixth, deeply nested subqueries are hard to read and debug; refactor them into CTEs. The author stresses treating SQL like production application code—with version control, code review, and performance tuning—investing in clean design upfront to avoid technical debt, and recommends Bill Karwin&amp;rsquo;s book &lt;em&gt;SQL Antipatterns&lt;/em&gt; for a deeper dive.&lt;/p&gt;
&lt;h2 id="build-your-own-database"&gt;&lt;a href="https://www.nan.fyi/database" rel="noopener noreferrer"&gt;Build Your Own Database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive tutorial guides readers through building a key-value database from scratch to demystify how LSM Trees work under the hood. It starts with a plain file, where in-place updates require expensive data shifting, motivating a switch to an append-only log: records are immutable, every write appends to the end of the file, and deletes write a special tombstone marker. To keep the file from growing forever, the log is split into fixed-size segments that are periodically compacted in the background to discard superseded records. Next, an in-memory hash table maps each key to its byte offset in the file for fast lookups without full-file scans, trading a bit of write speed for fast reads.&lt;/p&gt;
&lt;p&gt;Once segment data is stored in sorted order, we only need a smaller sparse index in memory because any key&amp;rsquo;s position can be narrowed down between two known index entries. To maintain sorted order while keeping writes fast, incoming writes go into a memtable (an in-memory balanced tree) backed by an append-only write-ahead log for crash recovery; when the memtable fills up, it flushes to disk as an immutable SSTable (Sorted String Table) with its own index. Combining the memtable, write-ahead log, and SSTables gives you an LSM Tree—the foundation of large-scale key-value stores like Google&amp;rsquo;s LevelDB and Amazon&amp;rsquo;s DynamoDB, whereas relational databases like PostgreSQL typically use B-trees for indexes (with table rows stored in heaps).&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 #26</title><link>https://miti99.com/en/post/2025/05/13/</link><pubDate>Tue, 13 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #26.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-philosophy-of-software-design--with-john-ousterhout"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-philosophy-of-software-design" rel="noopener noreferrer"&gt;The Philosophy of Software Design – with John Ousterhout&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt; podcast, Stanford professor John Ousterhout (author of &lt;em&gt;A Philosophy of Software Design&lt;/em&gt;) explains why software design matters even more in the age of AI. He compares today&amp;rsquo;s AI code-generation tools to a &amp;ldquo;tactical tornado&amp;rdquo;: they crank out working code at breakneck speed while easily leaving behind a trail of technical debt, meaning high-level architectural thinking remains firmly a human responsibility. At its core, Ousterhout says, software design is the art of decomposition—breaking a complex system into relatively independent modules. He also advocates the principle of &amp;ldquo;design it twice&amp;rdquo;: always force yourself to consider at least two genuinely different approaches before committing, because your second design is almost always better than your first.&lt;/p&gt;
&lt;p&gt;Ousterhout famously disagrees with several tenets of Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; school. He argues that strict TDD encourages developers to fixate on narrow tactical details rather than overall system architecture (though he likes writing tests first when fixing bugs), that splitting code into tiny methods proliferates shallow interfaces instead of the &amp;ldquo;deep modules&amp;rdquo; (simple interfaces hiding rich functionality) we should aim for, and that code comments are essential for capturing abstractions and field invariants that code alone cannot express. At Stanford, he teaches software design through intensive code reviews and comparing student solutions side by side, much like a creative writing workshop. He is currently contributing an implementation of the Homa transport protocol to the Linux kernel. It&amp;rsquo;s a must-listen episode for junior developers.&lt;/p&gt;
&lt;h2 id="20-years-of-git-still-weird-still-wonderful"&gt;&lt;a href="https://blog.gitbutler.com/20-years-of-git" rel="noopener noreferrer"&gt;20 years of Git. Still weird, still wonderful&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marking Git&amp;rsquo;s 20th anniversary, Scott Chacon (co-founder of GitHub and GitButler) looks back on the history of the tool. In April 2005, Linus Torvalds created Git as &amp;ldquo;the stupid content tracker&amp;rdquo; to replace BitKeeper and improve how the Linux kernel community collaborated via patches and tarballs. The very first commit contained just seven low-level C programs like &lt;code&gt;write-tree&lt;/code&gt; and &lt;code&gt;commit-tree&lt;/code&gt;, with zero concern for user-friendliness. Early on, Git was almost entirely low-level &amp;ldquo;plumbing,&amp;rdquo; while usable &amp;ldquo;porcelain&amp;rdquo; interfaces came from community shell-script wrappers like Cogito. Many familiar commands emerged organically: the original &lt;code&gt;git log&lt;/code&gt; was literally a three-line shell script piping &lt;code&gt;git-rev-list&lt;/code&gt; into &lt;code&gt;LESS&lt;/code&gt;, and &lt;code&gt;git rebase&lt;/code&gt; grew out of mailing-list discussions between Junio Hamano and Linus about patch workflows in 2005.&lt;/p&gt;
&lt;p&gt;Chacon also shares his personal journey: he originally used Git as a content distribution system for digital signage displays—matching Linus&amp;rsquo;s original &amp;ldquo;content tracker&amp;rdquo; philosophy—before writing the &lt;em&gt;Pro Git&lt;/em&gt; book and co-founding GitHub. In a fun bit of trivia, Git&amp;rsquo;s &amp;ldquo;octopus merge&amp;rdquo; strategy directly inspired GitHub&amp;rsquo;s Octocat mascot. Twenty years later, Git dominates software development while remaining as &amp;ldquo;weird and wonderful&amp;rdquo; as ever: an eccentric command-line UI sitting on top of a remarkably elegant data model.&lt;/p&gt;
&lt;h2 id="a-modest-critique-of-optional-handling"&gt;&lt;a href="https://mccue.dev/pages//4-5-25-optional-critique" rel="noopener noreferrer"&gt;A Modest Critique of Optional Handling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan McCue critiques how many Java developers misuse &lt;code&gt;java.util.Optional&lt;/code&gt; when refactoring methods that previously returned &lt;code&gt;null&lt;/code&gt;. In his view, &lt;code&gt;Optional&lt;/code&gt; shines in Stream pipelines and API return types, not as a wholesale replacement for &lt;code&gt;null&lt;/code&gt; inside method bodies. The conventional wisdom to avoid &lt;code&gt;.isPresent()&lt;/code&gt;/&lt;code&gt;.get()&lt;/code&gt; in favor of &lt;code&gt;.map()&lt;/code&gt; or &lt;code&gt;.ifPresent()&lt;/code&gt; quickly falls apart when you need to throw checked exceptions, combine multiple &lt;code&gt;Optional&lt;/code&gt; values, or mutate local variables inside a lambda; nesting &lt;code&gt;.ifPresent()&lt;/code&gt; calls also pushes code into deeply indented arrow anti-patterns.&lt;/p&gt;
&lt;p&gt;McCue&amp;rsquo;s proposed alternative is refreshingly simple: unwrap the &lt;code&gt;Optional&lt;/code&gt; immediately into a nullable local variable using &lt;code&gt;.orElse(null)&lt;/code&gt; and handle it with standard &lt;code&gt;if (x != null)&lt;/code&gt; control flow. Static analysis tools and IDEs already excel at tracking nullability on local variables, checked exceptions work naturally inside regular &lt;code&gt;if&lt;/code&gt; blocks, and the method signature still explicitly forces callers to confront the possibility of a missing value. Backed by concrete before-and-after refactorings, the post is a great reminder for junior developers to favor clear, maintainable code over dogmatically following &amp;ldquo;never call &lt;code&gt;.get()&lt;/code&gt;&amp;rdquo; lint rules.&lt;/p&gt;
&lt;h2 id="project-loom-structured-concurrency-in-java"&gt;&lt;a href="https://rockthejvm.com/articles/structured-concurrency-in-java" rel="noopener noreferrer"&gt;Project Loom: Structured Concurrency in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Riccardo Cardin at Rock the JVM provides a deep-dive tutorial on structured concurrency—part of Project Loom—running on Java 23 with &lt;code&gt;--enable-preview&lt;/code&gt;. He starts by showing the flaw in traditional unstructured concurrency with &lt;code&gt;ExecutorService&lt;/code&gt;: when a parent task fails or times out, child tasks can keep running in the background, leaking threads and wasting resources. Structured concurrency fixes this by enforcing the principle that the syntactic block structure of your code mirrors the runtime lifetime of its concurrent subtasks—meaning every child thread is guaranteed to finish before execution exits the enclosing lexical scope.&lt;/p&gt;
&lt;p&gt;At the center of the API is &lt;code&gt;StructuredTaskScope&lt;/code&gt;, which implements &lt;code&gt;AutoCloseable&lt;/code&gt; for &lt;code&gt;try-with-resources&lt;/code&gt; blocks and provides &lt;code&gt;fork()&lt;/code&gt; to spawn subtasks on virtual threads, &lt;code&gt;join()&lt;/code&gt; to await completion according to the scope&amp;rsquo;s policy, and &lt;code&gt;shutdown()&lt;/code&gt; to request cancellation of remaining subtasks. Cancellation is cooperative, and closing the scope still waits for all forked threads to terminate cleanly. Cardin illustrates this with a GitHub API client that fetches user profiles and repositories in parallel using the built-in &lt;code&gt;ShutdownOnFailure&lt;/code&gt; and &lt;code&gt;ShutdownOnSuccess&lt;/code&gt; policies. From there, he shows how to build custom policies by subclassing &lt;code&gt;StructuredTaskScope&lt;/code&gt; and overriding &lt;code&gt;handleComplete()&lt;/code&gt;, implementing functional helpers like &lt;code&gt;par()&lt;/code&gt;, &lt;code&gt;race()&lt;/code&gt;, &lt;code&gt;timeout()&lt;/code&gt;, and nested parent-child task trees. It is an excellent hands-on guide to writing safer, easier-to-reason-about concurrent code in modern Java.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://mccue.dev/pages/4-5-25-go-http-server" rel="noopener noreferrer"&gt;Go&amp;rsquo;s HTTP Server Patterns in Java 25&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan McCue demonstrates that modern Java can build HTTP servers in a lightweight, Go-like style by walking through a simple file-backed wiki web app written in Java 25. The application supports creating, viewing, and editing wiki pages stored as plain text files on disk. Its foundation is the JDK&amp;rsquo;s built-in &lt;code&gt;jdk.httpserver&lt;/code&gt; module, paired with McCue&amp;rsquo;s small &lt;code&gt;dev.mccue.jdk.httpserver&lt;/code&gt; helper library (which adds a clean &lt;code&gt;Body&lt;/code&gt; abstraction for writing responses), JMustache for HTML templating, and &lt;code&gt;dev.mccue.urlparameters&lt;/code&gt; for parsing form submissions.&lt;/p&gt;
&lt;p&gt;He models wiki entries with a &lt;code&gt;Page&lt;/code&gt; record exposing &lt;code&gt;save()&lt;/code&gt; and &lt;code&gt;load()&lt;/code&gt; methods, wires up dedicated request handlers for viewing, editing, and saving pages, and returns HTTP 302 redirects when users visit a nonexistent page. The walkthrough proves that with just the standard library and a few tiny, composable dependencies, you can build a clean web application in Java without reaching for a heavyweight framework. For high-traffic production workloads, he still suggests considering battle-tested servers like Jetty—while noting an important distinction in the JDK docs: the &amp;ldquo;testing, development, and debugging only&amp;rdquo; caveat applies specifically to &lt;code&gt;SimpleFileServer&lt;/code&gt; and the &lt;code&gt;jwebserver&lt;/code&gt; CLI tool, not to the underlying &lt;code&gt;jdk.httpserver&lt;/code&gt; HTTP/HTTPS API itself.&lt;/p&gt;
&lt;h2 id="java-is-dying-and-it-paid-off-my-mortgage"&gt;&lt;a href="https://alyosha.net/posts/java-is-dying-and-it-paid-off-my-mortgage/" rel="noopener noreferrer"&gt;Java is dying and it paid off my mortgage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alyosha looks back on the career anxiety they felt as a junior developer specializing in Java. On Hacker News and YouTube, Java was practically invisible compared to JavaScript and the latest hyped frameworks, making the author worry they were betting their career on a dying language. Once they actually entered the job market, however, they found the exact opposite: Java roles consistently led in pay, benefits, and stability, driven by profitable enterprises quietly running their core systems on the JVM.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, Java is in the sweet spot of a mature technology: nobody talks about it on social media, yet it powers massive economic value—and precisely because it is viewed as &amp;ldquo;uncool,&amp;rdquo; fewer new developers flock to it, keeping compensation high for those who know it well. Java skills bought the author&amp;rsquo;s house and paid off the mortgage. The lesson for junior developers: online hype does not reflect real-world hiring demand, and mastering a boring, rock-solid foundation often builds a far more lucrative and stable career than chasing the trend of the week.&lt;/p&gt;
&lt;h2 id="localhost-domains"&gt;&lt;a href="https://inclouds.space/localhost-domains" rel="noopener noreferrer"&gt;.localhost domains&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Chamberlain shares how he escaped having to memorize arbitrary port numbers like &lt;code&gt;localhost:4333&lt;/code&gt; or &lt;code&gt;localhost:5050&lt;/code&gt; when running multiple web apps locally. Instead, he gives each local project a memorable &lt;code&gt;.localhost&lt;/code&gt; domain such as &lt;code&gt;inclouds.localhost&lt;/code&gt;. His macOS setup has three moving parts: running each web app as a background service via &lt;code&gt;launchd&lt;/code&gt; listening on its own port; adding an entry in &lt;code&gt;/etc/hosts&lt;/code&gt; pointing the &lt;code&gt;.localhost&lt;/code&gt; domain to &lt;code&gt;127.0.0.1&lt;/code&gt;; and running Caddy as a local reverse proxy that routes each domain to its port while automatically handling internal TLS certificates and &lt;code&gt;gzip&lt;/code&gt;/&lt;code&gt;zstd&lt;/code&gt; compression. Here is the minimal config for an app running on port 5050:&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-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# /etc/hosts&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;127.0.0.1 inclouds.localhost
&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;# Caddyfile&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;inclouds.localhost &lt;span class="o"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; reverse_proxy localhost:5050
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; tls internal
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; encode gzip zstd
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="o"&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;Chamberlain admits that manually editing multiple system files is still a bit clunky and hopes to wrap the whole workflow into a single install/uninstall CLI command; a reader also pointed out that &lt;code&gt;dnsmasq&lt;/code&gt; can eliminate the manual &lt;code&gt;/etc/hosts&lt;/code&gt; edits. It&amp;rsquo;s a neat quality-of-life trick for keeping your local development environment organized when juggling several projects at once.&lt;/p&gt;
&lt;h2 id="ai-50-ai-agents-move-beyond-chat"&gt;&lt;a href="https://sequoiacap.com/article/ai-50-2025/" rel="noopener noreferrer"&gt;AI 50: AI Agents Move Beyond Chat&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://sequoiacap.com/wp-content/uploads/sites/6/2025/04/ai-50-2025.png" alt=""&gt;&lt;/p&gt;
&lt;p&gt;Konstantine Buhler at Sequoia Capital analyzes the firm&amp;rsquo;s 2025 AI 50 list and highlights a major shift: AI is moving from answering questions in a chat box to autonomously completing end-to-end work. Powered by agentic workflows and reasoning models, the companies on this year&amp;rsquo;s list don&amp;rsquo;t just handle isolated prompts—they own entire business workflows, turning AI into an &amp;ldquo;engine of action&amp;rdquo; inside the enterprise. Standout examples include Harvey handling end-to-end legal workflows from document review and drafting to case analysis, Sierra automating customer service resolution, and Cursor generating complete software features from natural-language specs.&lt;/p&gt;
&lt;p&gt;The piece also spotlights the rise of physical robotics, where transformer models meet hardware: Figure AI is building humanoid robots powered by its new Helix model, while Skild AI is developing a shared foundation model for general-purpose robotics—a market Nvidia estimates at $50 trillion. Buhler views 2025 as the inflection point where AI agents began taking on high-value enterprise work, and predicts that by 2026 consumer AI agents will take off in earnest, automatically managing calendars, booking travel, and organizing files as enterprise breakthroughs trickle into everyday life.&lt;/p&gt;
&lt;h2 id="interesting-images-from-bytebytego"&gt;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/65279cf0-3266-445d-852b-a45d6ac9afa4_2250x2862.png" alt="A Cheatsheet On OOP Design Patterns"&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>