<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Soft Skills on miti99</title><link>https://miti99.com/en/tags/soft-skills/</link><description>Recent content in Soft Skills 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/soft-skills/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 #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>