<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Productivity on miti99</title><link>https://miti99.com/en/tags/productivity/</link><description>Recent content in Productivity 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/productivity/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #106</title><link>https://miti99.com/en/post/2026/05/28/</link><pubDate>Thu, 28 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #106.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-heck-does-gps-work-an-interactive-exploration"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-gps-work" rel="noopener noreferrer"&gt;How The Heck Does GPS Work? (An Interactive Exploration)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shri Khalpada&amp;rsquo;s interactive explainer shows that GPS is fundamentally a machine for turning time into distance. Satellites broadcast radio signals at the speed of light, your phone measures how long the signal took to arrive, and each nanosecond corresponds to roughly 0.3 meters. One satellite tells you that you lie somewhere on a sphere (or circle in 2D), a second narrows it to two intersection points, and a third pins down a single point — a method called trilateration. The catch is the clock: satellites carry atomic clocks, while your phone only has a cheap quartz oscillator, and a drift of just a few microseconds throws your position off by hundreds of meters. That is why a fourth satellite is required: there is only one clock-offset correction that makes all four spheres intersect at a single point, allowing the receiver to solve for both exact position and exact time simultaneously.&lt;/p&gt;
&lt;p&gt;Then comes the &amp;ldquo;relativity tax&amp;rdquo;: because satellites move so fast, their clocks tick about 7 microseconds slower per day (special relativity), but higher up in weaker gravity they tick about 45 microseconds faster (general relativity). Left uncorrected, positions would drift by roughly 10 km per day, so satellite clocks are engineered to tick slightly slower before launch on the ground. In practice, modern receivers lock onto 8–12 satellites at once across GPS (US), GLONASS (Russia), Galileo (EU), and BeiDou (China) to reduce error; in dense cities, signals bouncing off buildings (multipath error) remain the hardest problem.&lt;/p&gt;
&lt;h2 id="if-ai-writes-your-code-why-use-python"&gt;&lt;a href="https://medium.com/@NMitchem/if-ai-writes-your-code-why-use-python-bf8c4ba1a055" rel="noopener noreferrer"&gt;If AI Writes Your Code, Why Use Python?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Noah Mitchem argues that the decade-long &amp;ldquo;bargain&amp;rdquo; — picking Python or TypeScript for their huge ecosystems, easier hiring, and fast prototyping while accepting 10x to 100x worse performance than Rust, Go, or C++ — has expired, because AI has gotten good at the hard languages. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 all topped 80% on SWE-bench Verified. The strict type systems and tight compiler feedback loops of Rust and Go let agents iteratively self-correct. The proof is already here: Microsoft ported the TypeScript compiler to Go (roughly 10x faster); Nicholas Carlini at Anthropic orchestrated 16 Claude agents to write a 100,000-line C compiler in Rust across nearly 2,000 Claude Code sessions for under $20,000; and Andreas Kling ported Ladybird&amp;rsquo;s JavaScript engine from C++ to Rust in two weeks — roughly 25,000 lines with zero regressions.&lt;/p&gt;
&lt;p&gt;Even the Python ecosystem is increasingly a &amp;ldquo;Rust ecosystem wearing a Python hat&amp;rdquo;: pydantic, polars, tokenizers, and orjson are all written in Rust; OpenAI acquired Astral (uv, ruff), and Anthropic acquired Bun. The unit of open-source contribution is also shifting from patches to full ports: Armin Ronacher used an agent to port MiniJinja from Rust to Go in 10 hours with only 45 minutes of actual human effort. Exceptions remain: Prisma moved back to a TypeScript/WASM core for serverless, PyTorch still commands roughly 85% of deep learning research, and Zig, Haskell, and Gleam lack training data. As the developer&amp;rsquo;s role shifts toward design and review, Python&amp;rsquo;s ease-of-writing advantage fades while the performance advantage of harder languages compounds every day.&lt;/p&gt;
&lt;h2 id="on-rendering-the-sky-sunsets-and-planets"&gt;&lt;a href="https://blog.maximeheckel.com/posts/on-rendering-the-sky-sunsets-and-planets/" rel="noopener noreferrer"&gt;On Rendering the Sky, Sunsets, and Planets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maxime Heckel walks through rendering atmospheric scattering in WebGL shaders from first principles up to near-photorealistic results. The foundation is raymarching: sampling atmospheric density along the view ray, computing transmittance via Beer&amp;rsquo;s Law, and using phase functions to describe scattering direction. Three physical mechanisms are combined: Rayleigh scattering (shorter wavelengths scatter more strongly, which is why the sky is blue), Mie scattering (larger particles like dust and aerosols that create the bright halo around the sun), and ozone absorption (filtering out specific wavelengths and deepening sunset colors).&lt;/p&gt;
&lt;p&gt;After building a flat sky, the author wraps the atmosphere around a spherical planet: reconstructing world-space coordinates from the depth buffer, using ray-sphere intersection to find atmospheric bounds, and handling depth so the atmosphere blends seamlessly with rendered geometry. With the exact same simulation framework, tweaking parameters produces a solar eclipse or a Martian sky. Finally, to hit real-time frame rates, the article implements Sébastien Hillaire&amp;rsquo;s lookup-table (LUT) method: precomputing transmittance, sky-view, and aerial perspective into textures and sampling them instead of running nested raymarching loops every frame. Packed with interactive widgets to tweak sun angle, altitude, Mie scattering, and ozone density, it is well worth reading directly.&lt;/p&gt;
&lt;h2 id="starting-systems-programming-pt-1-programmers-write-programs"&gt;&lt;a href="https://eblog.fly.dev/startingsystems1.html" rel="noopener noreferrer"&gt;Starting Systems Programming, Pt 1: Programmers Write Programs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the opening installment of Efron Amber Licht&amp;rsquo;s series on systems programming, built around a simple premise: to get good, you have to do the thing, and programmers write programs. In the author&amp;rsquo;s view, a problem counts as &amp;ldquo;systems&amp;rdquo; programming when it interacts with the OS or hardware, operates under tight performance constraints, or manipulates bytes and registers directly. A systems programmer views the computer as a physical machine that can be understood completely rather than an opaque abstraction, and isn&amp;rsquo;t afraid to take things apart to see how they work.&lt;/p&gt;
&lt;p&gt;The article opens the &amp;ldquo;black box&amp;rdquo; of a program by compiling a Go &amp;ldquo;hello world&amp;rdquo; binary and inspecting the executable directly. Readers build small tools from scratch along the way: &lt;code&gt;findoffset&lt;/code&gt; to locate a string inside a file, &lt;code&gt;echo&lt;/code&gt; and &lt;code&gt;cat&lt;/code&gt; to write and print files, &lt;code&gt;binpatch&lt;/code&gt; to patch binary contents directly without recompiling, and hexdump utilities to inspect machine code. Through these exercises, readers see that an executable is just an organized sequence of bytes: the string &lt;code&gt;&amp;quot;hello, world!&amp;quot;&lt;/code&gt; sits at a fixed offset, while the ELF header holds the magic number, target architecture, and the entry point where the CPU begins execution, with values stored in little-endian order on x86-64. The ethos the author wants to pass on: build your own tools, look at the raw data with your own eyes, and understand the system rather than hiding behind abstractions — because at the end of the day, it&amp;rsquo;s all just bytes.&lt;/p&gt;
&lt;h2 id="learning-software-architecture"&gt;&lt;a href="https://matklad.github.io/2026/05/12/software-architecture.html" rel="noopener noreferrer"&gt;Learning Software Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Replying to a physicist asking how to learn software architecture, Matklad argues that the skill is best learned by doing. University design courses felt to him like &amp;ldquo;kindergarteners playing firefighters&amp;rdquo;; what actually taught him architecture was unexpectedly becoming the lead of the IntelliJ Rust project. His second observation is Conway&amp;rsquo;s Law: software mirrors the social structure of the organization that builds it. He quotes neugierig: code ultimately matters less than architecture, and architecture matters less than social problems. Poor &amp;ldquo;scientific code,&amp;rdquo; therefore, stems mainly from incentive structures — like pressure to publish a paper in three months — rather than a lack of programming knowledge.&lt;/p&gt;
&lt;p&gt;There are two ways forward: very rarely, you get a chance to redesign a project&amp;rsquo;s incentive structure; most of the time, you have to accept the constraints and adapt the architecture around them. &lt;code&gt;rust-analyzer&lt;/code&gt; is a prime example: its deep, compiler-like core is kept trivial to build with a test suite that runs in seconds so it can attract strong contributors, while its wide surface of IDE features is isolated so that each feature is wrapped in &lt;code&gt;catch_unwind&lt;/code&gt; and operates on an immutable snapshot of data — allowing weekend contributors to submit imperfect code without crashes cascading or corrupting state. While he has no single &amp;ldquo;bible&amp;rdquo; book to recommend, he points readers to Gary Bernhardt&amp;rsquo;s talk &amp;ldquo;Boundaries,&amp;rdquo; Pieter Hintjens&amp;rsquo;s writings, Ted Kaminski&amp;rsquo;s blog, and Jamii&amp;rsquo;s post &amp;ldquo;Reflections on a decade of coding.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="i"&gt;&lt;a href="https://newsletter.weskao.com/p/im-an-introvert-this-is-how-i-get-myself-to-speak-up" rel="noopener noreferrer"&gt;I&amp;rsquo;m an introvert. This is how I get myself to speak up.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao shares her experience as an introvert in the workplace, where meetings naturally favor people who speak first and think out loud. Introverts prefer time to process before responding, putting them at a systematic disadvantage. Rather than waiting until you feel confident — a moment that usually never arrives — she recommends preparing ahead of time and using concrete tactics she relies on herself.&lt;/p&gt;
&lt;p&gt;Before a meeting, decide in advance that you are going to speak so you don&amp;rsquo;t waste energy debating yourself in the moment, and chime in early before prolonged self-doubt lets the opportunity slip away. Keeping a few go-to opening phrases ready, such as &amp;ldquo;That&amp;rsquo;s a great point. My POV on this is…&amp;rdquo;, makes jumping into a fast-moving discussion much easier. Written channels like docs and meeting notes serve as a parallel track for contributing and leave behind durable artifacts. Remote meetings also offer unique advantages for introverts (controlled lighting, framing, and small video tiles reduce pressure), and you can enlist a trusted colleague to give you a gentle prompt to hold yourself accountable.&lt;/p&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer-in-2026"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms-in-2026/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke reflects on how his LLM usage as a staff engineer has evolved over the past year, and the biggest shift is that agents have gotten genuinely good. In 2025 he only used AI for autocomplete, small edits in unfamiliar codebases, or Q&amp;amp;A; today, every code change starts by handing it to an agent (primarily via the GitHub Copilot app, running dozens of sessions a day). He skims the result for about 30 seconds, throws away most attempts because they aren&amp;rsquo;t what he had in mind, and carefully reviews and polishes the ones that survive. For bug reports, he feeds every single one to an agent first because it diagnoses the issue correctly about 80% of the time. Human expertise still matters, though: one bug took until the 14th agent session to crack, after he supplied context from logs and Slack, reproduced the issue himself, and narrowed the search space.&lt;/p&gt;
&lt;p&gt;He offloads a lot of testing and environment setup to agents: having them test their own changes and inspect the logs, write integration tests, and troubleshoot local machine configs. Test code is treated as &amp;ldquo;cheap,&amp;rdquo; whereas he avoids delegating UI work because agents still lack visual sensibility. Conversely, he still writes all his own PR descriptions, ADRs, Slack messages, and blog posts, because LLMs are overly verbose, struggle to surface the core point, and writing things yourself signals to coworkers that a real human is thinking on the other end. In his view, the most important AI skill today is delegating as much as possible to agents without pushing it too far.&lt;/p&gt;
&lt;h2 id="interrogatory-llm"&gt;&lt;a href="https://martinfowler.com/bliki/InterrogatoryLLM.html" rel="noopener noreferrer"&gt;Interrogatory LLM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler introduces the &amp;ldquo;Interrogatory LLM&amp;rdquo; pattern: instead of a human writing pages of context up front for a complex task, you ask the LLM to interview you, ask every question it needs answered, and synthesize the conversation into a context report that a subsequent session (potentially running a different model) uses to execute the task. He first spotted this technique on Harper Reed&amp;rsquo;s blog, noting the key trick of forcing the LLM to ask only one question at a time — a constraint Fowler found he had to remind the model of repeatedly when trying it himself.&lt;/p&gt;
&lt;p&gt;The pattern also works in reverse: hand an LLM an existing document, such as a software specification, and have it interview a domain expert to verify whether the spec is still accurate, replacing the tedious document review process that many experts struggle with. You can even combine both directions: one LLM drafts the document through an interview, and other LLMs take it to different experts for cross-examination. More broadly, while Fowler himself treats writing as an integral part of thinking, many people find writing painful; a structured conversation with an LLM can help them turn their tacit knowledge into written documentation.&lt;/p&gt;
&lt;h2 id="i-don"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2026-05-15-i-dont-think-ai-will-make-your-processes-go-faster/" rel="noopener noreferrer"&gt;I don&amp;rsquo;t think AI will make your processes go faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After rereading the classics &lt;em&gt;The Toyota Way&lt;/em&gt; and &lt;em&gt;The Goal&lt;/em&gt;, Frederick Van Brabant argues that AI won&amp;rsquo;t speed up organizational processes the way many expect, because we keep misidentifying the bottleneck. Looking at a project timeline, software development takes the longest chunk of time, so the knee-jerk reaction is to add headcount or assume AI will speed it up. But taking a long time doesn&amp;rsquo;t mean the problem originates there: nobody makes a project faster by typing faster. Most of that time is actually spent deciphering vague, title-only tickets like &amp;ldquo;send an email to the user when the order is completed&amp;rdquo; — what goes in the email, what happens on failure, and what counts as completed?&lt;/p&gt;
&lt;p&gt;AI generates code fast, but that doesn&amp;rsquo;t mean it generates the &lt;em&gt;right&lt;/em&gt; code. Comparisons between humans and AI routinely ignore the hand-holding required: to get AI to build the right thing, product and domain experts have to specify every feature and edge case down to the tiniest detail, ballooning the specification phase. Yet that level of clarity is what developers have wanted all along; if human engineers received specs that detailed, their productivity would skyrocket too. If you want faster processes, make sure the people doing the work have what they need to succeed — echoing &lt;em&gt;The Goal&lt;/em&gt;&amp;rsquo;s lesson that a bottleneck must be fed high-quality, predictable inputs.&lt;/p&gt;
&lt;h2 id="using-an-engineering-notebook"&gt;&lt;a href="https://ntietz.com/blog/using-an-engineering-notebook/" rel="noopener noreferrer"&gt;Using an Engineering Notebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicole Tietz shares what she considers perhaps her single most important productivity habit: handwriting in an engineering notebook, a practice borrowed from laboratory notebooks. The notebook records in rich detail what she is doing and why, thoroughly enough that someone else could reproduce the work; every entry is dated, written contemporaneously as the work happens, append-only without erasures or edits, and serves as the primary record rather than a neat copy transcribed from elsewhere. That level of detail matters because your future self is also &amp;ldquo;someone else&amp;rdquo; and will forget most of the context. She started the habit in 2016 while consulting for multiple clients at once, and now uses an e-ink tablet instead of paper notebooks because she is left-handed and doesn&amp;rsquo;t want to carry multiple physical notebooks around.&lt;/p&gt;
&lt;p&gt;The notebook delivers two main benefits. First, it acts as a memory aid: both as a log she can read back to recover context after an interruption, and because the physical act of handwriting improves retention. Second, it is a thinking tool: she routinely writes out a description of a planned code change in her notebook before touching the keyboard, forcing herself to think carefully and spot gaps in her understanding before writing a single line of code. She rarely rereads old notebooks and never shows them to anyone, because &amp;ldquo;the writing &lt;em&gt;is&lt;/em&gt; the work.&amp;rdquo; Her advice: if you haven&amp;rsquo;t tried keeping one, give it a shot and adapt the format, medium, and level of detail to fit your own style.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Documents:&lt;/strong&gt;
&lt;a href="https://static1.squarespace.com/static/50363cf324ac8e905e7df861/t/6a0af5d0484fbf5fe9a7743e/1779103184855/2026-Spring-AI.pdf" rel="noopener noreferrer"&gt;AI eats the world&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #102</title><link>https://miti99.com/en/post/2026/05/05/</link><pubDate>Tue, 05 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #102.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-github-agentic-workflow"&gt;&lt;a href="https://blog.frankel.ch/agentic-github-workflows/" rel="noopener noreferrer"&gt;A GitHub agentic workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel shares his hands-on experience with GitHub agentic workflows — workflows whose defining feature is running an AI agent inside them. He works on a long-lived product with many versions, accompanied by an analysis tool that warns customers ahead of time about upgrade issues. The tool&amp;rsquo;s configuration file used to be compiled manually by a colleague from release notes. Some deprecation info exists in source code via annotations like &lt;code&gt;@Deprecated&lt;/code&gt;, but plugin deprecations only appear in release notes — unstructured prose that traditional deterministic automation cannot parse. That is exactly where an agent shines.&lt;/p&gt;
&lt;p&gt;The workflow has four steps: initialize with &lt;code&gt;gh aw init&lt;/code&gt; or via the GitHub UI; write the workflow in Markdown (the author used Copilot CLI to help); &amp;ldquo;compile&amp;rdquo; it to YAML with &lt;code&gt;gh aw compile&lt;/code&gt;; and run it like a normal workflow using a fine-grained &lt;code&gt;GITHUB_COPILOT_TOKEN&lt;/code&gt; with &amp;ldquo;Copilot requests&amp;rdquo; permission. Along the way, the author hit several snags: forgetting to compile and pushing only the Markdown file; trying to create an auto-compile workflow before hitting permission walls and realizing it was a security risk anyway; and finally settling on a verification workflow that recompiles and fails if the output differs from the committed YAML, paired with &lt;code&gt;.gitattributes&lt;/code&gt; to handle line-ending differences between Windows and Ubuntu. Agentic workflows also disallowed actions from the GitHub Marketplace in his setup. In his view, they don&amp;rsquo;t replace deterministic workflows, but they unlock new use cases like parsing release notes that regexes can&amp;rsquo;t easily handle.&lt;/p&gt;
&lt;h2 id="the-20-software-engineering-laws"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/the-20-software-engineering-laws" rel="noopener noreferrer"&gt;The 20 Software Engineering Laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr Milan Milanović rounds up the 20 software engineering laws he references most often to explain why projects fail, systems degrade, and teams slow down. Many of these decades-old principles remain useful because they are about humans building products together under time pressure rather than any specific technology. They aren&amp;rsquo;t rigid rules: they describe what tends to happen, while the decisions still belong to the engineer.&lt;/p&gt;
&lt;p&gt;The laws are grouped into several themes: how systems are built (Gall&amp;rsquo;s Law, KISS, Conway&amp;rsquo;s Law, Hyrum&amp;rsquo;s Law, CAP Theorem, Zawinski&amp;rsquo;s Law), team dynamics (Brooks&amp;rsquo;s Law, Ringelmann Effect, Price&amp;rsquo;s Law), planning and estimation (Dunning-Kruger Effect, Hofstadter&amp;rsquo;s Law, Parkinson&amp;rsquo;s Law), measurement (Goodhart&amp;rsquo;s Law, Gilb&amp;rsquo;s Law), performance and reliability (Knuth&amp;rsquo;s Optimization Principle, Amdahl&amp;rsquo;s Law, Murphy&amp;rsquo;s Law), and design philosophy (Postel&amp;rsquo;s Law, Sturgeon&amp;rsquo;s Law, Cunningham&amp;rsquo;s Law). Illustrative examples include Instagram succeeding after stripping Burbn down to just photo sharing while feature-packed Google Wave vanished after 15 months, and the 2024 CrowdStrike outage that crashed 8.5 million Windows machines (Murphy&amp;rsquo;s Law). Understanding these laws before trouble strikes helps avoid costly mistakes; because they sometimes contradict one another, engineers need judgment to pick the right lens and build their own catalog of observed patterns.&lt;/p&gt;
&lt;h2 id="databases-were-not-designed-for-this"&gt;&lt;a href="https://arpitbhayani.me/blogs/defensive-databases/" rel="noopener noreferrer"&gt;Databases Were Not Designed For This&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpit Bhayani points out that every database design rests on an &amp;ldquo;implicit contract&amp;rdquo;: the caller is a human-written application running deterministic code, queries are reviewed before deployment, writes are intentional, and connections are short-lived. That contract held for forty years, but AI agents break it at every layer. Agents hallucinate novel queries on the fly, write data autonomously, duplicate writes on retries, hold connections open while waiting on LLM inference, and fan out into parallel sub-agents. A classic failure mode: an API returns HTTP 200 with an empty result because the backend connection pool is exhausted, and the agent interprets &amp;ldquo;no data&amp;rdquo; as &amp;ldquo;no problem,&amp;rdquo; proceeding to approve 500 transactions without triggering a single alert.&lt;/p&gt;
&lt;p&gt;The fix is defensive database design: set role-level statement timeouts (e.g., 5 seconds); use soft deletes with a &lt;code&gt;deleted_by&lt;/code&gt; column to audit which agent deleted what; use append-only event log tables for sensitive data; enforce idempotency keys derived from task ID, operation type, and target entity so retries don&amp;rsquo;t create duplicate records; and isolate agent traffic into a dedicated connection pool with short wait timeouts so it fails fast. The article also covers PgBouncer transaction pooling, attaching SQL comments with agent and task IDs for observability, and giving each agent type its own least-privilege database role. The core message: none of these are new tools — they are established best practices that become mandatory infrastructure once agents talk to your database.&lt;/p&gt;
&lt;h2 id="finishing-things"&gt;&lt;a href="https://ratfactor.com/finishing-things" rel="noopener noreferrer"&gt;Finishing Things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a personal essay by the author of the ratfactor blog about finishing personal projects amid life&amp;rsquo;s upheavals. He used to set grand annual themes like &amp;ldquo;The Year of the Microcontroller&amp;rdquo; (2023) or &amp;ldquo;The Year of Try It&amp;rdquo; (2024), but personal hardships and external events kept derailing them, so he decided to stop making big plans. What actually works is a &amp;ldquo;project stack&amp;rdquo;: every idea gets written on a small Post-It note and placed into a display frame, usually near the top, and he only works on the topmost item. This stack turns a sprawling maze of side quests into a single linear track that&amp;rsquo;s easy to follow instead of a tangled to-do list.&lt;/p&gt;
&lt;p&gt;He compares maintaining habits and projects to plate spinning: when a crisis hits, multiple plates come crashing down at once. His advice is to keep at least one plate spinning, because maintaining momentum is much easier than starting over from scratch; skills also need regular practice so they don&amp;rsquo;t rust. The essay introduces the &amp;ldquo;sphere of control,&amp;rdquo; a boundary that expands and contracts with life&amp;rsquo;s circumstances: as long as you do well within that sphere, there&amp;rsquo;s no need to beat yourself up, and some obstacles are really just minor discomforts, like dreading a phone call to book an appointment. He also touches on the creeping nihilism of watching AI companies scrape up human creativity, and chooses to ignore it and keep creating anyway. Conclusion: slow, steady progress is what actually gets things done, so instead of specific goals, he declares a &amp;ldquo;year of slow, steady progress.&amp;rdquo;&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_!9kS2!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F71595c9b-f94f-4ae8-851e-ea4f07342c29_2484x3002.png" alt="Data Warehouse vs Data Lake vs Data Mesh"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U4gw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8e8297aa-f856-4b2b-af5d-986023db89e7_2508x3000.png" alt="API Concepts Every Software Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SAsk!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7616a6b1-8eb6-4dc3-9456-b0e57bc9b0ee_2484x3002.png" alt="Polling vs Long Polling vs Webhooks vs SSE"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SJN6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F47ce48f1-06e7-4663-b822-96cc7d1307d0_2484x3002.png" alt="SLA vs SLO vs SLI"&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 #69</title><link>https://miti99.com/en/post/2025/12/12/</link><pubDate>Fri, 12 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #69. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; GLM-4.6&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-and-why-netflix-built-a-real-time-distributed-graph-part-1--ingesting-and-processing-data-streams-at-internet-scale"&gt;&lt;a href="https://netflixtechblog.com/how-and-why-netflix-built-a-real-time-distributed-graph-part-1-ingesting-and-processing-data-80113e124acc" rel="noopener noreferrer"&gt;How and Why Netflix Built a Real-Time Distributed Graph: Part 1 — Ingesting and Processing Data Streams at Internet Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;As Netflix expanded beyond on-demand video streaming into ad-supported tiers, live events, and mobile games, understanding a member&amp;rsquo;s journey across devices and business lines grew increasingly difficult. A microservices architecture with hundreds of services—each managing its own data store—fragmented the data and forced analytics teams to stitch records together manually. In response, Netflix&amp;rsquo;s data engineering team built the Real-Time Distributed Graph (RDG): modeling domain entities as a graph so relationships can be queried via multi-hop traversals across nodes and edges rather than expensive relational &lt;code&gt;JOIN&lt;/code&gt;s, making it easy to onboard new entity types and spot behavioral patterns or anomalies.&lt;/p&gt;
&lt;p&gt;Part 1 focuses on the ingestion and stream-processing pipeline. User interactions flow through the API Gateway into Kafka topics (some handling up to ~1 million messages per second, encoded in Avro and simultaneously archived to Apache Iceberg tables for historical backfills). Apache Flink jobs filter out noise, enrich events with metadata, transform raw events into graph nodes and edges, and batch and deduplicate updates within a short time window before writing over 5 million records per second into Netflix&amp;rsquo;s Data Mesh. A key operational lesson: running a single monolithic Flink job across all topics proved nearly impossible to tune, so the team moved to one Flink job per Kafka topic—accepting higher operational overhead in exchange for isolation and independent tuning.&lt;/p&gt;
&lt;h2 id="start-small-scale-smart-the-real-value-of-incremental-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-architecture-what-you" rel="noopener noreferrer"&gt;Start Small, Scale Smart: The Real Value of Incremental Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Incremental architecture is the practice of designing systems so they can evolve gracefully, grounded in Gall&amp;rsquo;s Law: if you start with a complex system from scratch, you will end up with a complex system that doesn&amp;rsquo;t work. In the author&amp;rsquo;s view, team organization matters more than technology: cross-functional teams that own a business domain end-to-end outperform layer-siloed teams, and if you want microservices, you must first build independent teams. Architects should act as mentors who still write code and steward system coherence rather than handing down mandates from an ivory tower, spreading knowledge through pair and mob programming. Instead of asking &amp;ldquo;how long will this take?&amp;rdquo;, ask &amp;ldquo;how can we make this smaller?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;On the technical side, the post advises applying architectural patterns only when you actually feel the pain they solve, using the Strangler Fig pattern to incrementally extract cleaner modules out of legacy monoliths, and building small, single-responsibility, replaceable components with firm boundaries—which naturally become candidates for future microservices. Event-driven architecture reduces coupling by letting components emit events instead of relying on central orchestration, while Domain-Driven Design and a shared Ubiquitous Language clarify events, consequences, and actors before anyone writes a line of code.&lt;/p&gt;
&lt;h2 id="java-interview-question---why-collection-doesn"&gt;&lt;a href="https://javabulletin.substack.com/p/java-interview-question-why-collection" rel="noopener noreferrer"&gt;Java Interview Question - Why Collection doesn&amp;rsquo;t extend Cloneable and Serializable interfaces?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interview question explores a classic Java design decision: why the root &lt;code&gt;Collection&lt;/code&gt; interface does not extend &lt;code&gt;Cloneable&lt;/code&gt; or &lt;code&gt;Serializable&lt;/code&gt;. The core reason is that not every collection can—or should—be cloned or serialized, so forcing both interfaces at the top of the hierarchy would impose unrealistic constraints on specialized implementations. For example, &lt;code&gt;Collections.unmodifiableList()&lt;/code&gt; is just a read-only view where deep cloning would break its semantics, &lt;code&gt;WeakHashMap&lt;/code&gt; relies on JVM-managed weak references that don&amp;rsquo;t make sense to serialize, and a &lt;code&gt;TreeMap&lt;/code&gt; configured with a non-serializable &lt;code&gt;Comparator&lt;/code&gt; cannot be serialized either. (Note that &lt;code&gt;ConcurrentSkipListMap&lt;/code&gt; actually &lt;em&gt;does&lt;/em&gt; implement both &lt;code&gt;Cloneable&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt;, so it isn&amp;rsquo;t an example of this restriction.)&lt;/p&gt;
&lt;p&gt;Furthermore, both &lt;code&gt;Cloneable&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt; are flawed marker interfaces from Java 1.0: &lt;code&gt;Cloneable&lt;/code&gt; declares no methods of its own and encourages error-prone shallow copies, while &lt;code&gt;Serializable&lt;/code&gt; creates versioning headaches and security vulnerabilities. When the Collections Framework was introduced in Java 1.2, its designers left it up to concrete classes like &lt;code&gt;ArrayList&lt;/code&gt; or &lt;code&gt;HashMap&lt;/code&gt; to opt in where appropriate, keeping the core abstraction clean. In modern Java, it&amp;rsquo;s better to copy collections via copy constructors like &lt;code&gt;new ArrayList&amp;lt;&amp;gt;(list)&lt;/code&gt; or &lt;code&gt;List.copyOf()&lt;/code&gt;, and use explicit formats like JSON instead of default Java serialization.&lt;/p&gt;
&lt;h2 id="we-stopped-roadmap-work-for-a-week-and-fixed-189-bugs"&gt;&lt;a href="https://lalitm.com/fixits-are-good-for-the-soul/" rel="noopener noreferrer"&gt;We stopped roadmap work for a week and fixed 189 bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares the story of a quarterly &amp;ldquo;Fixit Week,&amp;rdquo; where an organization of roughly 45 engineers paused all roadmap work for a full week. Across two time zones, 40 participating engineers squashed 189 bugs—averaging more than 4 bugs per person, with the top contributor fixing 12. The ground rules were strict: no single bug could take more than 2 days, work had to focus on small end-user papercuts or developer-productivity improvements, and all regular meetings, design reviews, and roadmap tasks were canceled. The event was gamified with point values scaled by task size, a live leaderboard, daily recaps, and custom t-shirts for awards like &amp;ldquo;first bug fixed&amp;rdquo; and &amp;ldquo;most annoying bug squashed.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Standout wins included closing a four-year-old feature request in a single day and shipping a 25-line GitHub Action that saved frontend engineers repetitive daily toil. Key ingredients for success were prepping a triaged, t-shirt-sized backlog ahead of time, reaching critical mass so the whole team felt the energy, keeping Fixit points strictly separate from performance reviews, and leaning on AI coding tools to lower the context-switching cost of jumping into unfamiliar directories. As the author concludes, Fixit Weeks restore pride in craftsmanship, the joy of shipping immediate improvements, and team camaraderie.&lt;/p&gt;
&lt;h2 id="the-math-of-why-you-can"&gt;&lt;a href="https://justoffbyone.com/posts/math-of-why-you-cant-focus-at-work/" rel="noopener noreferrer"&gt;The Math of Why You Can&amp;rsquo;t Focus at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post models knowledge-worker productivity using three parameters: λ, the rate of interruptions per hour (modeled as a Poisson process); Δ, the number of minutes needed to regain focus after each interruption; and θ, the minimum contiguous block of focused time required to make meaningful progress (typically 30–60 minutes for complex engineering work). Effective work capacity is the number of θ-sized blocks that fit inside the uninterrupted gaps—meaning that the same total number of hours, when chopped into fragments, yields drastically less output than contiguous blocks. Cited workplace studies suggest knowledge workers are interrupted every 2–3 minutes on average and take 10–16 minutes to refocus.&lt;/p&gt;
&lt;p&gt;Plug those typical workplace numbers into the math and deep work becomes nearly impossible—yet small shifts in any of the three parameters produce massive gains. The author points to three practical levers: lower λ by setting communication boundaries and defending calendar blocks, shrink θ to fit your environment by decomposing tasks into smaller self-contained steps, and reduce Δ through better context management, such as leaving yourself breadcrumb notes so you can resume work quickly after an interruption.&lt;/p&gt;
&lt;h2 id="tech-predictions-for-2026-and-beyond"&gt;&lt;a href="https://www.allthingsdistributed.com/2025/11/tech-predictions-for-2026-and-beyond.html" rel="noopener noreferrer"&gt;Tech predictions for 2026 and beyond&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels outlines five technology predictions for 2026 and beyond. First, physical AI will redefine companionship for vulnerable populations: loneliness affects one in six people worldwide and raises mortality risk by 32%, whereas clinical studies with the Paro robotic seal showed positive engagement in 95% of dementia patients. Second is the rise of the &amp;ldquo;renaissance developer&amp;rdquo;: generative AI will elevate rather than replace developers—just as compilers and cloud computing did before—because humans still own business constraints, customer empathy, and systems thinking. Third, quantum-safe security becomes urgent as the estimated qubit count needed to break 2048-bit RSA has dropped below one million, and Vogels predicts quantum computers capable of breaking RSA and elliptic-curve cryptography could arrive within roughly five years.&lt;/p&gt;
&lt;p&gt;Fourth, modern defense tech is being built as dual-use from day one, crossing over into civilian applications far faster than the 10–20-year lag of previous decades, with companies like Anduril reaching $1 billion in revenue in 2024. Finally, AI-powered personalized education will go mainstream: AI tutors cost around $4 a month, Khanmigo reached 1.4 million students in its first year, and teachers using AI tools save roughly 5.9 hours per week to reinvest in direct human teaching.&lt;/p&gt;
&lt;h2 id="why-i-still-love-linux"&gt;&lt;a href="https://it-notes.dragas.net/2025/11/24/why-i-still-love-linux/" rel="noopener noreferrer"&gt;Why I (still) love Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Marinelli reflects on nearly 30 years with Linux, starting in 1996 after his DOS and Commodore 64 days, when Linux gave him his first real taste of Unix and a sense of freedom no prior OS had offered. By 1998 he was actively contributing to the community as a speaker and translator. Even though the fabled &amp;ldquo;Year of the Linux Desktop&amp;rdquo; never quite arrived, Linux conquered mobile via Android, servers, and embedded devices, while Ubuntu helped bring Linux to everyday PCs and drew major enterprises into open source.&lt;/p&gt;
&lt;p&gt;Marinelli doesn&amp;rsquo;t hold back on criticisms either: many modern distributions have drifted away from the Unix philosophy of &amp;ldquo;do one thing and do it well,&amp;rdquo; most notably with &lt;code&gt;systemd&lt;/code&gt;; novelty for its own sake often sacrifices stability; corporate interests sometimes steer development toward their own agendas; and software quality has suffered from &amp;ldquo;vibe coding&amp;rdquo; and fragile dependency chains. Although he prefers BSD and illumos for many server workloads today, he still appreciates distributions like Alpine and openSUSE, notes how much better Linux hardware support has become, remains grateful to Linux for launching his career and lifelong learning, and expects to keep using it for another 30 years.&lt;/p&gt;
&lt;h2 id="why-senior-engineers-struggle-to-build-ai-agents"&gt;&lt;a href="https://www.philschmid.de/why-engineers-struggle-building-agents" rel="noopener noreferrer"&gt;Why (Senior) Engineers Struggle to Build AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Schmid explains why senior engineers often struggle more than juniors when building AI agents: traditional software engineering is deterministic, whereas LLM-backed agents are inherently probabilistic. Junior engineers tend to trust the model and ship quickly, while seasoned engineers instinctively try to &amp;ldquo;code away&amp;rdquo; the non-determinism. Schmid highlights five mindset shifts. First, natural language is the new state: a nuance like &amp;ldquo;the plan looks good, but focus on the US market&amp;rdquo; should be kept as rich text rather than squeezed into a rigid boolean or enum schema. Second, hand over control flow: let the model navigate unpredictable multi-turn conversations—like a user asking to cancel a subscription and changing their mind after hearing a retention offer—instead of hardcoding every branch.&lt;/p&gt;
&lt;p&gt;Third, errors are just another input: catch tool failures and feed the error message back into the agent&amp;rsquo;s context so it can self-correct, rather than throwing an unhandled exception. Fourth, move from unit tests to evals: alongside deterministic tests, measure end-to-end reliability, use LLM-as-a-judge for output quality, and inspect intermediate reasoning traces. Fifth, agents evolve while APIs stay fixed: because agents interpret tool schemas literally, APIs need clear docstrings and explicit parameter names like &lt;code&gt;user_email_address&lt;/code&gt; instead of &lt;code&gt;email&lt;/code&gt; to prevent hallucinations. Ultimately, engineers must trade a degree of rigid certainty for semantic flexibility.&lt;/p&gt;
&lt;h2 id="how-java-achieves-zero-copy-file-transfer"&gt;&lt;a href="https://javabulletin.substack.com/p/how-java-achieves-zero-copy-file" rel="noopener noreferrer"&gt;How Java Achieves Zero-Copy File Transfer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zero-copy is the technique of transferring file data from disk to a network socket without copying bytes through JVM user-space memory. Traditional file serving reads data from disk into the OS kernel page cache, copies it into a user-space JVM buffer, and copies it right back into a kernel socket buffer before sending it to the NIC; zero-copy lets the kernel move data directly between kernel buffers (from page cache to socket buffer and out via DMA to the network card), cutting CPU usage, context switches, and JVM garbage-collection pressure from temporary &lt;code&gt;byte[]&lt;/code&gt; allocations.&lt;/p&gt;
&lt;p&gt;Java exposes three main mechanisms here. &lt;code&gt;FileChannel.transferTo()&lt;/code&gt; delegates to the OS&amp;rsquo;s &lt;code&gt;sendfile&lt;/code&gt; syscall when the platform and target channel support it (&lt;code&gt;transferFrom()&lt;/code&gt; works in the opposite direction without the same universal syscall guarantee). &lt;code&gt;MappedByteBuffer&lt;/code&gt; maps file pages directly into the process&amp;rsquo;s virtual address space with read-only, read-write, or copy-on-write modes, avoiding user-space read copies though not automatically creating a zero-copy path to a network socket. For high-performance network servers, Netty&amp;rsquo;s &lt;code&gt;DefaultFileRegion&lt;/code&gt; wraps file channels to exploit native transport zero-copy. The technique does have limits: user-space TLS encryption usually breaks the direct kernel path because bytes must be encrypted before transmission, tiny files rarely justify the syscall setup overhead, and any in-flight data transformation like compression requires touching the bytes in memory anyway.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/20ed383c-5900-4f31-9041-afb5581b1ad4_2250x2624.png" alt="Top Strategies to Build High Availability Systems"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Eyti!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F862d0649-d77b-410f-95a5-6505c9eeb15a_2250x2814.png" alt="Cloudflare vs. AWS vs. Azure"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!52bX!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F65613a28-2320-4bb6-a610-5ab96b13240d_800x903.jpeg" alt="Popular Backend Tech Stack"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!JV_9!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa95473e0-5a68-43c6-841e-540a6b198d6d_2360x2960.png" alt="HTTP vs. HTTPS"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5rGo!,w_550,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fac99f98d-49a7-4933-b06f-8da0901d210e_800x939.gif" alt="Forward Proxy versus Reverse Proxy"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!qtkE!,w_550,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F4646c2e2-a6fb-44e7-a091-73fcbd8fa498_800x1040.gif" alt="Things Every Developer Should Know: Concurrency is NOT parallelism"&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 #45</title><link>https://miti99.com/en/post/2025/08/04/</link><pubDate>Mon, 04 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/04/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was put together using Cline + Kimi K2.&lt;/del&gt; Enjoy Newsletter #45.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-best"&gt;&lt;a href="https://www.paulgraham.com/best.html" rel="noopener noreferrer"&gt;The Best&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his essay &amp;ldquo;The Best Essay,&amp;rdquo; Paul Graham asks: what would the best possible essay look like? His first answer is that it must tackle the most important topic about which one can still say something surprising—but that line of thought leads toward major scientific discoveries, which are tied to the moment of their discovery rather than being timeless. So he reframes it into a more practical question: how do you write a truly great essay? According to Graham, everything starts with a compelling initial question where the writer has a fresh perspective or a distinct approach.&lt;/p&gt;
&lt;p&gt;The writing process turns vague ideas into concrete prose, followed by ruthless rereading and revision until the gap between the current answer and the truth becomes visible—sometimes opening up an entirely new direction. An essay works like a recursive exploration: each answer spawns new questions, and the writer should follow whichever branch offers the best combination of generality and novelty, ready to discard whole passages already written if they no longer serve the main thread. Although the initial question caps the maximum quality of the essay, Graham advises against being overly cautious when choosing topics; instead, write a lot, because most questions can yield a good essay. The ability to ask great questions comes from broad knowledge and deep experience across multiple fields.&lt;/p&gt;
&lt;h2 id="ai-tools-make-developers-19-slower-not-faster"&gt;&lt;a href="https://threadreaderapp.com/thread/1943360399220388093.html" rel="noopener noreferrer"&gt;AI Tools Make Developers 19% Slower, Not Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The research organization METR conducted a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories, which averaged over 22,000 stars and more than one million lines of code. Each task was randomly assigned to either allow or disallow AI tools (primarily Cursor Pro with Claude 3.5/3.7). The results were surprising: before the experiment, developers predicted AI would make them 24% faster; after finishing, they still felt they had been 20% faster; yet the actual measurements showed they were 19% slower when assisted by AI.&lt;/p&gt;
&lt;p&gt;The researchers emphasize that these findings apply specifically to this setting and do not represent the entire software industry; future models or more effective usage patterns could yield different outcomes. The slowdown appeared consistently across multiple metrics and stemmed from several factors at once: when allowed to use AI, developers spent time prompting the AI, waiting for responses, reviewing AI output, and idling, rather than directly writing code or looking up documentation. The takeaway is that the gap between subjective perception and actual productivity can be huge, so measure rather than relying on gut feeling when evaluating new tools.&lt;/p&gt;
&lt;h2 id="evolution-of-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/evolution-of-ubers-search-platform/" rel="noopener noreferrer"&gt;Evolution of Uber&amp;rsquo;s Search Platform&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article recounts the three-stage evolution of Uber&amp;rsquo;s search platform. Initially, Uber treated Elasticsearch (built on Apache Lucene) almost as a &amp;ldquo;black box,&amp;rdquo; with engineers focused mainly on keeping operations stable. A major limitation was Lucene&amp;rsquo;s near-real-time mechanism: new data became searchable only after being flushed to the index, introducing latency in time-sensitive scenarios like matching riders with drivers. Starting in 2019, Uber built Sia in-house, extending Lucene with an in-memory live index for real-time search, switching to lighter-weight gRPC/Protobuf communication, pull-based ingestion via Kafka, and active-active multi-region deployment. However, the complex custom architecture made it very difficult to adopt new Lucene features such as vector search, while most use cases didn&amp;rsquo;t actually need real-time freshness.&lt;/p&gt;
&lt;p&gt;In 2024, with Project Sunrise, Uber recognized that maintaining a custom fork was no longer sustainable and migrated to OpenSearch, becoming a founding member of the OpenSearch Software Foundation. The current architecture separates the write path from the read path: data from Kafka is compacted into optimized segments and uploaded to remote storage, while search nodes simply download them to serve queries, keeping all ingestion overhead off the query path. Uber also contributed features back to OpenSearch 3.0, including pull-based ingestion and gRPC APIs. The lesson: custom-built solutions are expensive to maintain when the ecosystem moves fast, and complexity should only be accepted where it is genuinely needed.&lt;/p&gt;
&lt;h2 id="vercel"&gt;&lt;a href="https://leerob.com/vercel" rel="noopener noreferrer"&gt;Vercel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson reflects on his five years at Vercel, where he grew from an individual engineer to VP, watching the company scale from 30 people and $1 million in ARR to 650 people and over $200 million. His first lesson is work-life balance: he once answered work messages even during his honeymoon, and only broke free by building processes and hiring people capable enough to run things themselves. Second, speed is a competitive advantage: asking &amp;ldquo;what would it take to ship this next week?&amp;rdquo; forces teams to find creative solutions, and even if you miss the deadline, you still finish faster than if you had set none at all.&lt;/p&gt;
&lt;p&gt;Third, scaling requires hiring rather than doing everything yourself—always be recruiting, keep the bar high, and only hire candidates who genuinely excite you. Fourth, avoid unilateral decisions: he once parachuted into a product launch at the last minute and demanded changes without full context, something he regrets; leaders should get involved early and build consensus before making calls. Finally, stay adaptable and admit mistakes: personally reviewing every company social media post created a bottleneck, and delegating ownership alongside clear quality guidelines produced better results. These are valuable lessons for any developer moving toward a leadership role.&lt;/p&gt;
&lt;h2 id="tools"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/3/tools/" rel="noopener noreferrer"&gt;Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that when working with AI agents, &amp;ldquo;code is all you need.&amp;rdquo; He critiques the MCP protocol, which lets language models invoke external tools and services: this approach is hard to compose because every step depends on model inference, consumes substantial context on each tool call, and scales poorly when automating repetitive tasks. In his view, without AI, a software engineer solves problems by writing code—so AI should do the same.&lt;/p&gt;
&lt;p&gt;Model-generated code has explicit logic that humans can inspect, runs repeatedly at low cost once written, and is easier to debug. As an illustration, Armin describes migrating his entire blog from reStructuredText to Markdown: the model wrote AST-based conversion scripts, wrote additional scripts comparing the old and new HTML to verify the output, and iterated on that feedback loop with almost no human intervention. Here, the model acted as a code quality evaluator rather than manually executing each step. He concludes that MCP looks like a dead end for large-scale automation, and a more promising path is combining code generation with having the model evaluate the results after execution.&lt;/p&gt;
&lt;h2 id="how-i-build-software-quickly"&gt;&lt;a href="https://evanhahn.com/how-i-build-software-quickly/" rel="noopener noreferrer"&gt;How I Build Software Quickly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn shares how he builds software quickly while maintaining acceptable quality. The core principle is balancing speed and quality: aim for &amp;ldquo;8 out of 10, delivered on time&amp;rdquo; rather than chasing perfection. What counts as &amp;ldquo;good enough&amp;rdquo; depends on context—a 24-hour game jam tolerates messy code, whereas a pacemaker demands excellence—so you need to understand what your team considers good enough. He recommends building a rough draft first, full of TODOs, hardcoded data, and unhandled errors, to uncover unforeseen problems early, avoid wasting effort on code that will be thrown away, and prevent premature abstraction.&lt;/p&gt;
&lt;p&gt;Doing less is also a way to move faster: question the scope, combine screens, skip unnecessary edge cases, or trim API parameters. To stay focused, he sets timers for tasks and pair-programs. Small changes are easier to write, review, revert, and debug—for instance, fixing a bug, upgrading a library, and adding a feature in separate changes. The skills that speed him up most include reading code (the most important one), data modeling, writing automation scripts, using a debugger, taking breaks, writing pure functions, and leveraging LLM tools.&lt;/p&gt;
&lt;h2 id="the-most-mysterious-bug-i-solved-at-work"&gt;&lt;a href="https://cadence.moe/blog/2025-07-02-the-most-mysterious-bug-i-solved-at-work/" rel="noopener noreferrer"&gt;The Most Mysterious Bug I Solved at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cadence recounts the most mysterious bug she ever solved on an electronic patient referral application in Australia, a system that converts referral data into HL7, CDA, or PDF formats to send to healthcare providers. Occasionally, the system threw the error &lt;code&gt;Illegal Character entity: expansion character (code 0x2) not a valid XML character&lt;/code&gt;. Character &lt;code&gt;0x2&lt;/code&gt; (Start of Text) is an obsolete control character from the early days of computing with virtually no modern use—yet it was showing up inside referral letters typed by doctors.&lt;/p&gt;
&lt;p&gt;Investigation gradually uncovered the clues: the affected letters all had unusual hard line breaks, and the same doctor was submitting identical letters multiple times. It turned out the doctor was copying text from PDFs of previous referrals stored in their practice management software, and character &lt;code&gt;0x2&lt;/code&gt; appeared right where hyphens sat at the ends of lines in the PDF. The culprit was Microsoft Edge&amp;rsquo;s built-in PDF viewer—the default on Windows—which mistakenly converted end-of-line hyphens into &lt;code&gt;0x2&lt;/code&gt; when copying text. The team fixed the issue by automatically replacing &lt;code&gt;0x2&lt;/code&gt; with a hyphen rather than stripping it, preserving the intended text. The story reminds developers that the root cause of a bug sometimes lies outside the codebase, in users&amp;rsquo; habits and the tools they rely on.&lt;/p&gt;
&lt;h2 id="how-to-think-about-time-in-programming"&gt;&lt;a href="https://shanrauf.com/archive/how-to-think-about-time-in-programming" rel="noopener noreferrer"&gt;How to Think About Time in Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shan Rauf lays out a clear mental model for handling time in programming. The foundation is absolute time, consisting of &amp;ldquo;instants&amp;rdquo; and &amp;ldquo;durations&amp;rdquo;: an instant is represented as seconds elapsed since a reference point called an epoch (Unix uses January 1, 1970), while a duration is the length of time between two instants, so comparisons and calculations require only basic arithmetic. Humans, however, use civil time based on the Gregorian calendar, with months of varying lengths. UTC defines the second using atomic clocks and occasionally inserts leap seconds to stay aligned with Earth&amp;rsquo;s rotation, meaning a day can be 86,401 or 86,399 seconds long; JavaScript&amp;rsquo;s &lt;code&gt;Date&lt;/code&gt; ignores leap seconds. Time zones are not fixed offsets but evolving sets of rules: during daylight saving transitions, certain civil times are skipped or repeated twice, and the IANA time zone database (such as &lt;code&gt;America/New_York&lt;/code&gt;) records known rules and historical transitions, though it does not guarantee accuracy for every location prior to 1970.&lt;/p&gt;
&lt;p&gt;In practice, chat messages should be stored in UTC and displayed in the viewer&amp;rsquo;s local time zone. For events, intent matters: a class held at a physical location should be stored as local time plus a time zone identifier, whereas an absolute event like a solar eclipse should be stored in UTC. The author recommends bundling the IANA database and updating it regularly, using Unicode CLDR data to display friendly time zone names, and never assuming a UTC offset is immutable. The advice &amp;ldquo;just use UTC&amp;rdquo; isn&amp;rsquo;t enough, because converting to UTC too early discards information about the user&amp;rsquo;s original intent.&lt;/p&gt;
&lt;h2 id="phrase-origin-why-do-we"&gt;&lt;a href="https://quuxplusone.github.io/blog/2025/04/04/etymology-of-call/" rel="noopener noreferrer"&gt;Phrase origin: Why do we &amp;ldquo;call&amp;rdquo; functions?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arthur O&amp;rsquo;Dwyer investigates why we say we &amp;ldquo;call&amp;rdquo; a function. There are three intuitive hypotheses: calling as in visiting a friend (dropping by, staying a while, then leaving), calling as in summoning a servant to do a task, or calling on the telephone to ask a question and get an answer. The real answer is closest to the second hypothesis, but via a detour through library science: in closed-stack libraries, patrons &amp;ldquo;called for&amp;rdquo; books by their shelf mark—the term &amp;ldquo;call number&amp;rdquo; coined by Melvil Dewey in 1876. Early computer scientists borrowed this metaphor for subroutine libraries, where programmers &amp;ldquo;called&amp;rdquo; prewritten routines off the shelf much like a librarian retrieving a book by its call number.&lt;/p&gt;
&lt;p&gt;The timeline shows the evolution clearly: in 1947, John Mauchly wrote about subroutines being &amp;ldquo;called in&amp;rdquo; from a library on magnetic tape; in 1956, MANIAC II assembly used a &amp;ldquo;call number&amp;rdquo; to identify subroutines; in 1958, Fortran II introduced the &lt;code&gt;CALL&lt;/code&gt; statement, turning &amp;ldquo;call&amp;rdquo; into a runtime action; around 1959–1960, Algol and other languages adopted the term; in 1961, the verb phrase &amp;ldquo;call a subroutine&amp;rdquo; was first recorded in Burroughs documentation; and by 1963, modern usage had settled into MIT&amp;rsquo;s curriculum. The author concludes that Fortran II&amp;rsquo;s &lt;code&gt;CALL&lt;/code&gt; keyword is what cemented &amp;ldquo;call&amp;rdquo; as the standard verb for invoking a function.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing again with many URLs, it seems Cline + Kimi K2 overflowed its context window; after compacting, it forgot parts of the context and easily got confused, needing repeated reminders that this environment is Windows and requires PowerShell-compatible commands instead of Linux ones. On top of that, it made a few silly mistakes like summarizing&amp;hellip; the wrong URL :&amp;gt;&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #29</title><link>https://miti99.com/en/post/2025/05/16/</link><pubDate>Fri, 16 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/16/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #29 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-clean-approach-to-process-optimization"&gt;&lt;a href="https://queue.acm.org/detail.cfm?id=3722546" rel="noopener noreferrer"&gt;A Clean Approach to Process Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas A. Limoncelli opens with an everyday example: how he reorganized doing the dishes at home. Instead of waiting until the start of a wash cycle to add detergent to the dishwasher, he does it right after unloading the clean dishes. Simply reordering the steps made the chore smoother without any extra effort. He then applied this exact mindset to customer onboarding at his company, cutting wait times from several days down to just a few minutes.&lt;/p&gt;
&lt;p&gt;The core idea is to split a process into two phases. The slow phase covers generic tasks that can be done in advance before an order arrives; the fast phase handles only the specific customization after the order comes in. Alongside this, review optional tasks, since they are often unnecessary or can be done more efficiently. For junior developers, this is a practical lesson: the same approach applies to software deployment pipelines, infrastructure provisioning, and many other areas, improving both performance and service quality.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="microsoft"&gt;&lt;a href="https://www.gatesnotes.com/microsoft-original-source-code" rel="noopener noreferrer"&gt;Microsoft&amp;rsquo;s Original Source Code Released for 50th Anniversary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;To mark Microsoft&amp;rsquo;s 50th anniversary, Bill Gates released the original source code for Altair BASIC, the company&amp;rsquo;s first product, calling it the &amp;ldquo;coolest&amp;rdquo; code he has ever written. The story began with the January 1975 cover of Popular Electronics featuring the Altair 8800 computer from MITS. Gates and Paul Allen contacted founder Ed Roberts and told him they already had a version of BASIC for the Altair&amp;rsquo;s chip, even though they hadn&amp;rsquo;t written a single line yet. The pair chose to build an interpreter rather than a compiler because running code line by line gave beginners immediate feedback and made debugging easier.&lt;/p&gt;
&lt;p&gt;Since they didn&amp;rsquo;t have an Intel 8080 chip, Allen wrote a simulator for it on Harvard&amp;rsquo;s PDP-10 mainframe, Gates wrote the core interpreter, and Monte Davidoff handled the math package. After about two months of working day and night, they squeezed the entire interpreter into just 4 KB of memory using compact data structures and efficient algorithms, because memory at the time cost more than the computer itself. The demo succeeded, MITS licensed the software, and Micro-Soft was born. For developers today, it is a vivid example of optimizing under extreme hardware constraints; Gates tells the fuller story in his memoir &amp;ldquo;Source Code.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="no-code-is-dead-long-live-vibe-coding"&gt;&lt;a href="https://kenneth.io/post/no-code-is-dead-long-live-vibe-coding" rel="noopener noreferrer"&gt;No code is dead. Long live vibe coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kenneth Auchenberg makes a blunt call: in 2025, no-code is dead. For a decade, no-code and low-code platforms promised to democratize software creation, yet none truly broke through or replaced traditional programming. Instead, a new generation of tools powered by AI and large language models is emerging, known as &amp;ldquo;vibe coding.&amp;rdquo; Tools like Bolt, Lovable, and v0 show that generating real, production-grade code from natural-language descriptions is not only viable, but better than drag-and-drop WYSIWYG editors.&lt;/p&gt;
&lt;p&gt;According to the author, users turned out not to want &amp;ldquo;less code&amp;rdquo;—they wanted a better way to write code. They don&amp;rsquo;t want to be locked into proprietary runtimes; they want real source code, full control, and the freedom to edit and deploy anywhere. The previous generation, such as Webflow and Retool, bundled the editor, hosting, runtime, and UI components into a closed system. Now, large language models can generate clean React code that follows open standards and industry best practices, ready to deploy onto open infrastructure. The author calls this the &amp;ldquo;unbundling&amp;rdquo; of no-code.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="simple-scalable-and-global-containers-are-coming-to-cloudflare-workers-in-june-2025"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-containers-coming-2025/" rel="noopener noreferrer"&gt;Simple, scalable, and global: Containers are coming to Cloudflare Workers in June 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced that Containers will enter open beta in late June 2025. Workers are already the simplest way to deploy software globally, but there are workloads they cannot handle: running user-generated code in arbitrary languages, executing CLI tools that require a full Linux environment, using multiple gigabytes of memory or multiple CPU cores, or lifting and shifting applications from AWS, GCP, or Azure without a rewrite. Containers fill that gap. With just a few lines of Wrangler configuration and &lt;code&gt;wrangler deploy&lt;/code&gt;, containers spin up on demand near the user, go to sleep after a configurable timeout, and support autoscaling based on CPU usage.&lt;/p&gt;
&lt;p&gt;What sets them apart is the architecture: each container is backed by a Durable Object acting as a programmable &amp;ldquo;sidecar,&amp;rdquo; letting you start, stop, run commands, and monitor container state directly from code. That allows Workers to act as an API gateway, service mesh, or orchestrator for containers without writing Kubernetes operators or configuring a complex control plane. On pricing, users pay only for the time a container actually runs, billed per vCPU, memory, and disk at rates Cloudflare says are competitive with Google Cloud Run. The takeaway: handle the bulk of requests with lightweight, inexpensive Workers, and reach for containers only for heavy workloads that truly need them.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-types-of-companies-you-can-work-for-and-what-they-do-for-your-career"&gt;&lt;a href="https://www.elenaverna.com/p/the-types-of-companies-you-can-work" rel="noopener noreferrer"&gt;The types of companies you can work for and what they do for your career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elena Verna advises choosing where you work intentionally rather than chasing titles or compensation. She breaks companies into six archetypes. &amp;ldquo;Unicorns&amp;rdquo; grow around 100% year over year, like early Miro or Figma: the pace is breakneck and burnout is a real risk, but experience there opens many doors. &amp;ldquo;Tankers&amp;rdquo; like Google, Apple, and Microsoft run with mature processes, high pay, and abundant training resources—great for starting a career, though roles are highly specialized and progress is slow. &amp;ldquo;Declining Giants&amp;rdquo; are in constant reorganization; pressure for results is intense, but advancement can be fast. &amp;ldquo;Survival Mode&amp;rdquo; startups haven&amp;rsquo;t found product-market fit yet: autonomy is high and skills broaden quickly, but the risk is steep and the author advises newcomers to avoid them.&lt;/p&gt;
&lt;p&gt;The remaining two are &amp;ldquo;Lifestyle Boats,&amp;rdquo; often bootstrapped, profitable, and sustainably growing like Basecamp, which are great for beginners thanks to a supportive environment; and &amp;ldquo;Social Good Seekers,&amp;rdquo; where social impact comes before revenue—pay may be lower, but fulfillment is high. To identify which type a company is, ask about headcount, revenue growth over the past three years, and how much runway remains before the next fundraise. At the same time, ask yourself how much change and pressure you can tolerate, whether you need a clearly defined role, and what your current financial priorities are.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-to-create-a-chain-reaction-of-good-habits"&gt;&lt;a href="https://jamesclear.com/domino-effect" rel="noopener noreferrer"&gt;How to Create a Chain Reaction of Good Habits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Clear, author of &amp;ldquo;Atomic Habits,&amp;rdquo; explains the Domino Effect: when you change one behavior, it sets off a chain reaction that shifts related behaviors too. He shares the story of Jennifer Dukes Lee, who didn&amp;rsquo;t make her bed for over twenty years; after doing it four days in a row, she found herself folding laundry, washing the dishes, and organizing the kitchen cabinets. A 2012 Northwestern University study similarly found that when people cut down their sedentary time, they naturally ate less fat even though nobody asked them to. The effect works for bad habits as well—checking your phone leads to scrolling social media, which turns into twenty more minutes of procrastination.&lt;/p&gt;
&lt;p&gt;Clear argues this happens because daily habits are tightly interconnected and because of the principle of commitment and consistency: once we make even a tiny commitment, we tend to follow through because it aligns with our self-image. To deliberately trigger a positive domino chain, start with the small habit you feel most motivated to do and practice it consistently, ride the momentum of finishing one task straight into the next, and when things get hard, break them into smaller pieces and focus on consistency rather than outcomes. Remarkably, the effect doesn&amp;rsquo;t just create new behaviors—it shifts beliefs: each falling domino helps you believe in a new version of yourself and build identity-based habits.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-post-developer-era"&gt;&lt;a href="https://www.joshwcomeau.com/blog/the-post-developer-era/" rel="noopener noreferrer"&gt;The Post-Developer Era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Two years after writing &amp;ldquo;The End of Front-End Development&amp;rdquo; when GPT-4 launched, Josh W. Comeau revisits whether we have entered a &amp;ldquo;post-developer era.&amp;rdquo; His answer is no. The headline figure that &amp;ldquo;AI writes over 25% of code at Google&amp;rdquo; is easy to misread, because AI isn&amp;rsquo;t working autonomously—skilled developers are always at the wheel, steering and editing. Meanwhile Devin, pitched as an autonomous replacement for software engineers, completed only 3 out of 20 tasks in an independent team&amp;rsquo;s real-world evaluation. Comeau uses Cursor with Claude Sonnet and finds it impressive, but compares it to cruise control: take your hands off the wheel and the car slowly drifts out of its lane. Non-programmers won&amp;rsquo;t spot subtle bugs and eventually end up stuck with an unmaintainable mess.&lt;/p&gt;
&lt;p&gt;The job market remains tough, but Comeau attributes that primarily to high interest rates, waves of layoffs at large tech companies, and the mistaken belief among executives that AI is about to make developers redundant—not to AI actually replacing people. He also worries that newcomers will fall into &amp;ldquo;vibe coding,&amp;rdquo; endlessly clicking accept without understanding the code. Conversely, if you use AI actively as a personal tutor, there has never been a better time to learn programming, and a &amp;ldquo;developer renaissance&amp;rdquo; may follow once companies realize AI is a force multiplier rather than a replacement.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="everything-wrong-with-model-context-protocol-mcp"&gt;&lt;a href="https://blog.sshh.io/p/everything-wrong-with-mcp" rel="noopener noreferrer"&gt;Everything Wrong With Model Context Protocol (MCP)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar examines the flaws and limitations of the Model Context Protocol, the standard for connecting third-party tools and data to AI assistants like Claude, ChatGPT, and Cursor. On protocol security, the initial version didn&amp;rsquo;t define an authentication mechanism and the subsequent specification drew criticism for its complexity; running MCP servers locally over stdio creates a shortcut for less experienced users to download and execute malware; and many servers trust inputs and execute them directly. On user experience, MCP doesn&amp;rsquo;t distinguish risk levels between a tool that reads logs and one that deletes files, offers no token-cost controls, and at the time of writing only returned unstructured text—something later specs addressed.&lt;/p&gt;
&lt;p&gt;More serious is the security of the language models themselves. Tool descriptions are typically injected into the system prompt, giving them outsized influence over the agent; a server can silently rename or rewrite tool descriptions after the user has approved them, and data pulled from fourth-party sources—such as a database row—can carry prompt injections. Easy data aggregation also lets employees infer sensitive information from data they are individually permitted to view. Finally, model reliability drops when too many tools are exposed, and simple primitives like listing or reading files fall short of the queries users expect. Shankar concludes that safe adoption requires a secure-by-default protocol, applications that protect users, and users who understand the trade-offs of their choices.&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 #25</title><link>https://miti99.com/en/post/2025/05/12/</link><pubDate>Mon, 12 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #25.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-13-software-engineering-laws"&gt;&lt;a href="https://newsletter.manager.dev/p/the-13-software-engineering-laws" rel="noopener noreferrer"&gt;The 13 software engineering laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides rounds up 13 classic &amp;ldquo;laws&amp;rdquo; every software engineer and engineering manager should know. On time and staffing: Parkinson&amp;rsquo;s Law (work expands to fill the time allotted) is counterbalanced by Hofstadter&amp;rsquo;s Law (it always takes longer than you expect), meaning estimation only improves through practice, communication, and flexible scope. Brooks&amp;rsquo;s Law reminds us that adding people to a late software project makes it later. Conway&amp;rsquo;s Law states that system architecture mirrors an organization&amp;rsquo;s communication structure; Flo applied the &amp;ldquo;Inverse Conway Maneuver&amp;rdquo; by embedding iOS, Android, and backend engineers into cross-functional teams to ship 20–30 releases per day. Cunningham&amp;rsquo;s Law offers a clever way to get unstuck: open a pull request—even if you aren&amp;rsquo;t sure it&amp;rsquo;s right—and the owning team will quickly jump in to show you the right way.&lt;/p&gt;
&lt;p&gt;On products and teams: Sturgeon&amp;rsquo;s Law (90% of everything is crud) and Zawinski&amp;rsquo;s Law (every program attempts to expand until it can read mail) warn against feature bloat, while Hyrum&amp;rsquo;s Law guarantees that with enough users, every observable behavior of your system will be depended on by someone, making removals painful. Price&amp;rsquo;s Law (half the work is done by the square root of the total number of contributors) and the Ringelmann Effect (individual effort drops as group size grows) explain why small teams with clear ownership outperform large ones. Goodhart&amp;rsquo;s Law (when a measure becomes a target, it ceases to be a good measure) is balanced by Gilb&amp;rsquo;s Law (imperfect measurement beats no measurement at all). Rounding out the list is Murphy&amp;rsquo;s Law. Zaides concludes that while these aren&amp;rsquo;t physical laws of nature, they are invaluable mental models.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-curve-is-bending-predictions-on-near-term-ai-inference-spending"&gt;&lt;a href="https://grantslatton.com/the-curve-is-bending" rel="noopener noreferrer"&gt;The Curve is Bending: Predictions on near-term AI inference spending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grant Slatton, creator of the high-performance spreadsheet engine Row Zero, argues that AI has just crossed an inflection point where the economic value it generates for real-world software engineering exceeds its cost. His personal AI spend jumped from $100/year in 2023 to roughly $5,000/year in 2025. For him, &lt;code&gt;o1-pro&lt;/code&gt; was the first model that felt reliably useful, performing on par with a junior engineer on self-contained single-file tasks—such as pinpointing a bug given a large Rust file, a git diff, and failing test output. He uses Zed Editor&amp;rsquo;s prompt library to generate repetitive spreadsheet functions (cutting 20 minutes of work down to 2), writes small LLM-powered CLI utilities for himself, and used Claude Code—sometimes running three sessions in parallel—to rewrite the entire backend of his personal website, finishing what he estimated as a 100-hour job in under 10 hours for a few hundred dollars.&lt;/p&gt;
&lt;p&gt;Looking ahead from April 2025, Slatton estimates AI tools currently boost his overall productivity by ~1.1x and expects that to reach 2–3x by late 2026. Frontier models like &lt;code&gt;o3-pro&lt;/code&gt; will initially be expensive, but for engineers earning over $100/hour, an annual AI inference budget of $10,000–$50,000 is easy to justify—and by Jevons paradox, falling per-token prices will only increase total spending. He notes that models still lack the architectural &amp;ldquo;taste&amp;rdquo; of a senior engineer, predicts coding agents will match new CS grads by the end of 2026, and advises junior developers to focus on cultivating senior-level judgment as quickly as possible.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="open-source-is-just-that-understanding-boundaries-in-open-source"&gt;&lt;a href="https://vale.rocks/posts/open-source-entitlement" rel="noopener noreferrer"&gt;Open-Source is Just That: Understanding Boundaries in Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Declan Chidlow speaks out against the growing sense of user entitlement directed at volunteer open-source maintainers. As Chidlow points out, open-source software grants specific rights defined by its license—and merely making source code public does not even make a project open source; it does not automatically mean a project accepts external contributions, offers user support, owes anyone new features, or owes anyone the maintainer&amp;rsquo;s personal time, and users remain bound by the license terms. Having permission to use code under a license does not entitle anyone to demand unpaid labor from its author. He criticizes users who spam issue trackers or aggressively demand support, commenters who defend that behavior, and especially profitable companies that build on open source without giving back instead of funding the maintainers they depend on.&lt;/p&gt;
&lt;p&gt;For projects that do welcome engagement, asking for help respectfully means searching existing issues and documentation first, providing complete reproduction details upfront, staying patient and polite, using official channels, and contributing small fixes or docs improvements where you can—and even when you sponsor or pay a maintainer, &amp;ldquo;money does not replace manners.&amp;rdquo; He encourages the community to respectfully stand up for maintainers, urges maintainers to set firm boundaries, and warns against flooding projects with thoughtless AI-generated issues and pull requests. The bottom line: access to source code is not access to someone else&amp;rsquo;s time and labor.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-insanity-of-being-a-software-engineer"&gt;&lt;a href="https://0x1.pt/2025/04/06/the-insanity-of-being-a-software-engineer/" rel="noopener noreferrer"&gt;The Insanity of Being a Software Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitor Sousa Pereira takes a satirical look at the ever-expanding mountain of knowledge a single software engineer is expected to master. At first, you just needed a couple of languages and tools, plus your company&amp;rsquo;s web framework of choice—Rails, Django, or Laravel—alongside CSS, which you can study your whole life and still not understand why a layout broke. Then React arrived, companies decided they didn&amp;rsquo;t want to hire separate specialists, and the &amp;ldquo;full-stack developer&amp;rdquo; was born—bringing TypeScript, Redux, webpack/esbuild/rollup configs, Prettier, and ESLint along for the ride. Next, DevOps replaced dedicated sysadmins, so developers had to learn Docker, AWS, and Terraform or Pulumi too. Getting promoted into management means learning an entirely new profession—estimating timelines, delegating, writing specs, running annual performance reviews—and unless the company is growing fast, you still have to do all your old IC work on top of it.&lt;/p&gt;
&lt;p&gt;Pereira mentions a recruiter recently reaching out for a role demanding senior-level expertise across Rails, Hotwire, &lt;em&gt;and&lt;/em&gt; native mobile development simultaneously. While acknowledging that software complexity exists for real reasons, he asks what happened to specialization: when building a house, you hire an architect, a structural engineer, an electrician, a plumber, and dozens of other trades—nobody expects one person to do it all. He closes half-jokingly that maybe a future where we build entire applications with a few AI prompts wouldn&amp;rsquo;t be so bad after all.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-day-i-taught-ai-to-understand-code-like-a-senior-developer"&gt;&lt;a href="https://nmn.gl/blog/ai-understand-senior-developer" rel="noopener noreferrer"&gt;The day I taught AI to understand code like a Senior Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Namanyay argues that today&amp;rsquo;s code-generating LLMs don&amp;rsquo;t truly understand a codebase—they act like glorified autocomplete tools that forget where files live, duplicate existing helpers, and ignore established design patterns because they only see a narrow context window. Junior developers focus on the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; whereas senior developers focus on the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;what if,&amp;rdquo; holding a mental model of the entire system and anticipating ripple effects; current LLMs behave much more like juniors. His solution is modeling the codebase as a hierarchical knowledge graph using an algorithm he calls Ranked Recursive Summarization (RRS): starting at leaf files, ranking their importance, and recursively summarizing upward into parent directories. Because plain RRS still lost domain-specific nuance, he evolved it into Prismatic RRS (PRRS), which summarizes the codebase through multiple &amp;ldquo;prisms&amp;rdquo; such as architecture, data flow, and security.&lt;/p&gt;
&lt;p&gt;With this multi-perspective context, the AI knows where new files belong, which patterns to follow, and how to extend existing abstractions instead of reinventing them—while also surfacing technical debt, security gaps, and speeding up onboarding for human engineers. He packaged this approach into a product called Giga AI, but also shares how developers can apply the idea manually: write concise summaries for key directories and files, have AI refine them, maintain perspective-specific docs, and feed the relevant summaries into context. His core belief: AI should amplify human creativity rather than replace it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="why-companies-don"&gt;&lt;a href="https://idiallo.com/blog/companies-dont-fix-bugs" rel="noopener noreferrer"&gt;Why Companies Don&amp;rsquo;t Fix Bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ibrahim Diallo opens with the famous GTA Online story: a player named &lt;code&gt;t0st&lt;/code&gt; diagnosed why the game&amp;rsquo;s online mode took 20 minutes to load, fixed it with 13 lines of code that cut load times by 70%, and was awarded $10,000 by Rockstar—after the bug had sat in production for eight years. Rather than blaming &amp;ldquo;lazy developers,&amp;rdquo; Diallo traces the typical lifecycle of a bug inside a large company: in year one, an engineer proposes fixing the slow JSON parser, the product manager asks &amp;ldquo;is it in the spec?&amp;rdquo;, and it gets filed under tech debt; by year three, all engineering capacity is locked into expansion packs and paid cosmetics; by year six, the ticket is auto-archived because the codebase has been rewritten twice; in year eight, a newly hired developer discovers the exact same bug all over again.&lt;/p&gt;
&lt;p&gt;He identifies four structural reasons bugs go unfixed: roadmap-driven development pushes any fix not tied to a feature request to the bottom of the backlog; constant employee turnover erodes institutional knowledge; touching poorly tested, undocumented legacy code carries high career risk for little reward; and quality-of-life improvements don&amp;rsquo;t show up on quarterly revenue charts the way selling virtual Shark Cards does. &lt;code&gt;t0st&lt;/code&gt;&amp;rsquo;s fix was a great PR win, but it didn&amp;rsquo;t change the underlying incentives. The takeaway: don&amp;rsquo;t blame individual engineers when the system itself treats user experience as an afterthought.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="3-buckets-of-work-time"&gt;&lt;a href="https://corymiller.com/3-buckets-of-work-time/" rel="noopener noreferrer"&gt;3 Buckets of Work Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cory Miller, a Chief Evangelist working remotely from Oklahoma with a largely European team, audited his calendar and realized his workweek falls into three buckets. The first is &lt;em&gt;talking&lt;/em&gt;—communication and collaboration across meetings and Slack/Teams—which has been taking a larger share than usual since he recently joined a new team. The second is &lt;em&gt;doing&lt;/em&gt;—execution and shipping—which for him mostly means producing internal and customer-facing videos. The third is &lt;em&gt;thinking about work&lt;/em&gt;—strategy and vision, the &amp;ldquo;daydreaming&amp;rdquo; bucket tied to his Wonder and Invention strengths in the Working Genius model, best done alone in quiet reflection before bringing rough ideas back to teammates for feedback.&lt;/p&gt;
&lt;p&gt;Now in his late 40s, having lived through burnout before and raising two young kids with his wife, Miller has no interest in working 60-hour weeks; he wants to work smarter and healthier. He admits that fear and uncertainty often drive him to overcommit, so he is practicing letting go of what he can&amp;rsquo;t control. Wanting enough structure to feel grounded without feeling boxed in, he is experimenting with waking up at 6 a.m. to handle European overlap and communication early, dedicating Mondays and Wednesdays to collaboration, and reserving Tuesdays and Thursdays for deep work and strategic thinking—leaving himself more quiet space to embrace &amp;ldquo;not knowing yet.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="dangerous-advice-for-software-engineers"&gt;&lt;a href="https://www.seangoedecke.com/dangerous-advice/" rel="noopener noreferrer"&gt;Dangerous Advice for Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke compares certain kinds of career advice to &amp;ldquo;sharp tools&amp;rdquo; like &lt;code&gt;ssh&lt;/code&gt;, &lt;code&gt;kubectl&lt;/code&gt;, or write access to a production database: wielded with skill and judgment, they are indispensable; used carelessly, they cause serious damage. Goedecke admits he frequently writes this kind of &amp;ldquo;dangerous&amp;rdquo; advice: deciding for yourself what to work on, occasionally breaking written company rules on purpose, holding strong opinions before you have all the facts, embracing a bit of organizational cunning, and avoiding work that doesn&amp;rsquo;t directly serve shipping. He worries about readers misapplying it, but argues someone still needs to write it down.&lt;/p&gt;
&lt;p&gt;First, most mainstream career advice is sanitized—written to avoid liability or sound virtuous—while strong engineers crave honest talk about how organizations actually work; realizing that reality doesn&amp;rsquo;t match the employee handbook while nobody admits it out loud is deeply isolating. Second, your own manager can almost never give you this advice directly: if you misjudge a situation and say &amp;ldquo;my manager told me to break the process,&amp;rdquo; the fallout hits them even harder than it hits you, even though many managers quietly wish their reports operated with more pragmatic initiative than their job description states. This advice is high-risk, high-reward—helpful for strong engineers and dangerous for weaker ones—so if any piece of it makes you uncomfortable, don&amp;rsquo;t follow it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="on-the-biology-of-a-large-language-model"&gt;&lt;a href="https://transformer-circuits.pub/2025/attribution-graphs/biology.html" rel="noopener noreferrer"&gt;On the Biology of a Large Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This landmark Anthropic paper uses &amp;ldquo;circuit tracing&amp;rdquo; to study the internal mechanisms of Claude 3.5 Haiku, likening the approach to a biologist studying living tissue under a microscope. The researchers train a replacement model built on a cross-layer transcoder architecture containing roughly 30 million interpretable &amp;ldquo;features&amp;rdquo; (replacement neurons that typically correspond to human-understandable concepts), then construct attribution graphs for individual prompts to trace how features activate one another step by step. Because attribution graphs are hypotheses, they validate them with intervention experiments—such as inhibiting specific feature clusters inside the original model and observing how behavior changes across multi-step reasoning, poetry, multilingual understanding, addition, medical diagnosis, hallucinations, refusals, jailbreaks, and chain-of-thought faithfulness.&lt;/p&gt;
&lt;p&gt;Their experiments reveal that the model performs genuine multi-step intermediate reasoning &amp;ldquo;in its head&amp;rdquo;—for example, activating &amp;ldquo;Texas&amp;rdquo; before arriving at &amp;ldquo;Austin&amp;rdquo; when asked for the capital of the state containing Dallas—alongside memorized shortcuts. It shows clear signs of forward planning, choosing a rhyming target word before composing a line of poetry; possesses rudimentary &amp;ldquo;metacognitive&amp;rdquo; circuits that track what it knows versus doesn&amp;rsquo;t know; and operates on shared abstract representations across languages. While the authors acknowledge their current tools yield satisfying explanations for only about a quarter of prompts, the work represents a major step forward for AI interpretability and safety.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>