<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>LLM on miti99</title><link>https://miti99.com/en/tags/llm/</link><description>Recent content in LLM 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/llm/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 #101</title><link>https://miti99.com/en/post/2026/05/04/</link><pubDate>Mon, 04 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #101.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ai-assisted-engineering-q1-2026-impact-report"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-assisted-engineering-q1-2026-impact" rel="noopener noreferrer"&gt;AI-Assisted Engineering: Q1 2026 Impact Report&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DX&amp;rsquo;s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI&amp;rsquo;s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping &lt;strong&gt;4x&lt;/strong&gt; as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the &amp;ldquo;player-coach&amp;rdquo; model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save &lt;strong&gt;4.9 hours per week&lt;/strong&gt;, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.&lt;/p&gt;
&lt;p&gt;The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is &amp;ldquo;no longer optional.&amp;rdquo; &amp;ldquo;Shadow AI&amp;rdquo; — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI&amp;rsquo;s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.&lt;/p&gt;
&lt;h2 id="my-ai-workflow-without-losing-my-skills"&gt;&lt;a href="https://marcgg.com/blog/2026/04/15/my-current-ai-workflow/" rel="noopener noreferrer"&gt;My AI Workflow (Without Losing My Skills)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G shares how he leverages AI without losing his programming skills. His concern stems from the &amp;ldquo;automation paradox&amp;rdquo; (he cites an episode of the &lt;em&gt;99% Invisible&lt;/em&gt; podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he &amp;ldquo;vibe codes&amp;rdquo; freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an &amp;ldquo;Omega Mess,&amp;rdquo; in Sandi Metz&amp;rsquo;s terminology).&lt;/p&gt;
&lt;p&gt;A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.&lt;/p&gt;
&lt;h2 id="managing-context-in-long-run-agentic-applications"&gt;&lt;a href="https://slack.engineering/managing-context-in-long-run-agentic-applications/" rel="noopener noreferrer"&gt;Managing Context in Long-Run Agentic Applications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is &lt;strong&gt;never carrying raw conversation history into subsequent agent calls&lt;/strong&gt;; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren&amp;rsquo;t weighed down by accumulated stale context.&lt;/p&gt;
&lt;p&gt;The first channel is the &lt;strong&gt;Director&amp;rsquo;s Journal&lt;/strong&gt;, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the &lt;strong&gt;Critic&amp;rsquo;s Review&lt;/strong&gt;, which scores the confidence of specialist agents&amp;rsquo; findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the &lt;strong&gt;Critic&amp;rsquo;s Timeline&lt;/strong&gt;, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director&amp;rsquo;s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.&lt;/p&gt;
&lt;h2 id="how-the-heck-does-shazam-work"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-shazam-work" rel="noopener noreferrer"&gt;How The Heck Does Shazam Work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: &lt;strong&gt;throw away almost all the data&lt;/strong&gt;, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a &lt;strong&gt;Fast Fourier Transform (FFT)&lt;/strong&gt; to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse &amp;ldquo;constellation map&amp;rdquo;; background noise rarely produces prominent peaks, making this approach highly noise-resistant.&lt;/p&gt;
&lt;p&gt;To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an &lt;strong&gt;inverted index&lt;/strong&gt; — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.&lt;/p&gt;
&lt;h2 id="agents-with-taste"&gt;&lt;a href="https://emilkowal.ski/ui/agents-with-taste" rel="noopener noreferrer"&gt;Agents with Taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain &lt;em&gt;why&lt;/em&gt; a design choice works, then feed them to the agent. His argument is that taste isn&amp;rsquo;t magic — &amp;ldquo;almost every decision about taste has a rational explanation if you look closely enough,&amp;rdquo; and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.&lt;/p&gt;
&lt;p&gt;The examples are concrete: animations should start from &lt;code&gt;scale(0.95)&lt;/code&gt; rather than &lt;code&gt;scale(0)&lt;/code&gt; because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as &lt;code&gt;ease-out&lt;/code&gt; for elements entering the viewport and &lt;code&gt;ease&lt;/code&gt; for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.&lt;/p&gt;
&lt;h2 id="floating-point-from-scratch-hard-mode"&gt;&lt;a href="https://essenceia.github.io/projects/floating_dragon/" rel="noopener noreferrer"&gt;Floating Point from Scratch: Hard Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose &lt;strong&gt;bfloat16&lt;/strong&gt; (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a &lt;strong&gt;dual-path&lt;/strong&gt; architecture: the &amp;ldquo;close path&amp;rdquo; handles subtraction when the exponent difference is less than 2, while the &amp;ldquo;far path&amp;rdquo; handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.&lt;/p&gt;
&lt;p&gt;Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library&amp;rsquo;s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of &lt;strong&gt;454 MHz&lt;/strong&gt; under nominal conditions. One fun lesson: a leading-zero counter written simply with &lt;code&gt;casez&lt;/code&gt; outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.&lt;/p&gt;
&lt;h2 id="the-peril-of-laziness-lost"&gt;&lt;a href="https://bcantrill.dtrace.org/2026/04/12/the-peril-of-laziness-lost/" rel="noopener noreferrer"&gt;The Peril of Laziness Lost&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bryan Cantrill argues that LLMs are eroding one of a great programmer&amp;rsquo;s most important virtues: &lt;strong&gt;laziness&lt;/strong&gt;, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a &lt;em&gt;natural filter&lt;/em&gt; forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.&lt;/p&gt;
&lt;p&gt;A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan&amp;rsquo;s output revealed redundant test suites, a &amp;ldquo;Hello World&amp;rdquo; Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and &amp;ldquo;grind&amp;rdquo; culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.&lt;/p&gt;
&lt;h2 id="cleaning-up-merged-git-branches-a-one-liner-from-the-cia"&gt;&lt;a href="https://spencer.wtf/2026/02/20/cleaning-up-merged-git-branches-a-one-liner-from-the-cias-leaked-dev-docs.html" rel="noopener noreferrer"&gt;Cleaning Up Merged Git Branches: A One-Liner from the CIA&amp;rsquo;s Leaked Dev Docs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against &lt;code&gt;master&lt;/code&gt;; his updated version for modern repositories compares against &lt;code&gt;origin/main&lt;/code&gt; and excludes both &lt;code&gt;main&lt;/code&gt; and &lt;code&gt;develop&lt;/code&gt;:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git branch --merged origin/main &lt;span class="p"&gt;|&lt;/span&gt; grep -vE &lt;span class="s2"&gt;&amp;#34;^\s*(\*|main|develop)&amp;#34;&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; xargs -n &lt;span class="m"&gt;1&lt;/span&gt; git branch -d
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;The pipeline chains three steps: &lt;code&gt;git branch --merged origin/main&lt;/code&gt; lists merged branches, &lt;code&gt;grep -vE&lt;/code&gt; strips out the current branch and primary branches to prevent accidental deletion, and &lt;code&gt;xargs&lt;/code&gt; deletes each remaining branch using the lowercase &lt;code&gt;-d&lt;/code&gt; flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his &lt;code&gt;ciaclean&lt;/code&gt;) so you don&amp;rsquo;t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.&lt;/p&gt;
&lt;h2 id="agent-harness-engineering"&gt;&lt;a href="https://addyosmani.com/blog/agent-harness-engineering/" rel="noopener noreferrer"&gt;Agent Harness Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that the quality of a coding agent depends more on its &lt;strong&gt;harness&lt;/strong&gt; — the operational scaffolding around the model — than on the model itself: &amp;ldquo;a mediocre model with a great harness will beat a great model with a bad harness.&amp;rdquo; The gap between what today&amp;rsquo;s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (&lt;code&gt;AGENTS.md&lt;/code&gt;, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.&lt;/p&gt;
&lt;p&gt;Key principles include the &amp;ldquo;skill issue&amp;rdquo; mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The &lt;strong&gt;Ratchet Principle&lt;/strong&gt; treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its &lt;code&gt;AGENTS.md&lt;/code&gt; under 60 lines, like a pilot&amp;rsquo;s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn&amp;rsquo;t disappear — it moves on to tackling harder problems.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #100</title><link>https://miti99.com/en/post/2026/05/03/</link><pubDate>Sun, 03 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/03/</guid><description>&lt;p&gt;&lt;em&gt;Well, it&amp;rsquo;s been a long time since I wrote a Newsletter entirely by myself. My writing skills have probably gotten rusty. But to mark the milestone of Newsletter #100, I&amp;rsquo;ll try to write a bit on my own. This post won&amp;rsquo;t have any &lt;code&gt;AI-Assisted&lt;/code&gt; tag, and I&amp;rsquo;ll focus on articles that are already in Vietnamese. I&amp;rsquo;ll also mainly share my personal experiences rather than summarizing like the AI does. Hopefully it won&amp;rsquo;t disappoint you — just think of it as a nice change of pace!^^&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&amp;ldquo;Enjoy Newsletter #100&amp;rdquo;!^^&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="bên-trong-moonshot-kimi"&gt;&lt;a href="https://dentmakers.substack.com/p/ben-trong-moonshot-kimi" rel="noopener noreferrer"&gt;Bên trong Moonshot (Kimi)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is a translation of an original Chinese article about the author&amp;rsquo;s interviews with employees inside Moonshot (the company behind Kimi). Honestly, reading it left me deeply admiring and drawn to the work culture described (though of course it might not match reality 100% — I can&amp;rsquo;t be sure, since articles often paint a rosier picture than real life). I really love the model of a company built as a gathering of geniuses, letting them &amp;ldquo;swim on their own,&amp;rdquo; make their own decisions, and build everything themselves — no bosses, no KPIs, etc. Even though I don&amp;rsquo;t know how effective this model is in practice, or how it holds up under commercial pressure from investors, I genuinely love that spirit of striving for improvement and pouring oneself tirelessly into the work out of pure passion (perhaps because I&amp;rsquo;m no longer that passionate about my current job). Still, I know Moonshot wouldn&amp;rsquo;t be for me, since I&amp;rsquo;m no genius, I don&amp;rsquo;t speak Chinese, and honestly my passion for the industry in general and my company in particular just isn&amp;rsquo;t what it used to be back in my sophomore and junior years of college (the part I loved most was coding, and AI has taken that over :v while the remaining parts — planning, code review, sending to QC, deploying, etc. — all have to be done manually or reviewed. Reviewing code I didn&amp;rsquo;t write myself is genuinely such a headache).&lt;/p&gt;
&lt;p&gt;That&amp;rsquo;s just me venting a bit — I still have huge respect for my current company and bosses. Back when I was a wide-eyed intern, I found a company that gave me what felt like a very generous offer at the time, and it also gave me the opportunity to fulfill many of my dreams. Compared to many of my peers, I can consider myself pretty accomplished. And the company truly &amp;ldquo;survived&amp;rdquo; through tough times like COVID-19 — in fact, it thrived during that period and hit some unbelievable targets. I really should know how to be content :)))&lt;/p&gt;
&lt;h2 id="goclaw-30---một-bước-ngoặt-lớn"&gt;&lt;a href="https://goonnguyen.substack.com/p/goclaw-30-mot-buoc-ngoat-lon" rel="noopener noreferrer"&gt;GoClaw 3.0 - Một bước ngoặt lớn!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Duy /Zuey/ (Mr.Goonie) is someone I follow closely, and thanks to him I&amp;rsquo;ve been exposed to a lot of perspectives and stayed up to date with news in tech in general and AI in particular. He&amp;rsquo;s the founder and creator of several companies and projects. Among them, I bought &lt;a href="https://claudekit.cc/" rel="noopener noreferrer"&gt;ClaudeKit&lt;/a&gt; to support him and have been really happy with it. It has helped me a ton in my daily work as well as in experimenting with Claude Code.&lt;/p&gt;
&lt;p&gt;Quick 30-second plug: you can use my referral link &lt;a href="https://claudekit.cc/?ref=BWA910UK" rel="noopener noreferrer"&gt;here&lt;/a&gt; to buy ClaudeKit and give it a try. Duy very generously offers a 14-day no-questions-asked refund.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://goclaw.sh/" rel="noopener noreferrer"&gt;GoClaw&lt;/a&gt; is another product he&amp;rsquo;s involved with. With the launch of GoClaw v3.0, he wrote this post to clarify that GoClaw is not a fork of OpenClaw, but rather inspired by it and implemented from scratch by the team. I&amp;rsquo;ve tried GoClaw since earlier versions, around v2. Personally, I find GoClaw quite user-friendly and easier to use than OpenClaw. The trade-off, however, is that it isn&amp;rsquo;t compatible with and is harder to extend using OpenClaw&amp;rsquo;s skill ecosystem like ClawHub. That said, GoClaw has one feature I find truly groundbreaking: Agent Team. Agents have their own distinct &amp;ldquo;souls&amp;rdquo; and instructions, and they can interact with each other inside a team. GoClaw also makes it very easy to trace issues and see exactly what an agent is doing. As a backend dev, that&amp;rsquo;s where GoClaw really wins me over. If I had to name a downside, GoClaw manages permissions quite strictly, which can be a bit annoying when you ask it to do something and it can&amp;rsquo;t — especially when working with files in workspaces. I&amp;rsquo;m not sure whether that&amp;rsquo;s due to breaking changes between versions or if it was designed that way from the start. Check out the article for more details and install GoClaw to try it out yourself.&lt;/p&gt;
&lt;h2 id="claude-opus-47---phân-tích-hành-vi-sau-3-ngày-sử-dụng"&gt;&lt;a href="https://goonnguyen.substack.com/p/claude-opus-47-phan-tich-hanh-vi" rel="noopener noreferrer"&gt;Claude Opus 4.7 - Phân tích hành vi sau 3 ngày sử dụng&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Another post from Duy, sharing his observations on Claude Opus 4.7 after three days of use. Sorry, I honestly don&amp;rsquo;t know what else to write for this one :(((&lt;/p&gt;
&lt;h2 id="ai--các-nghề-mới-trong-kỷ-nguyên-agents"&gt;&lt;a href="https://goonnguyen.substack.com/p/ai-and-cac-nghe-moi-trong-ky-nguyen" rel="noopener noreferrer"&gt;AI &amp;amp; Các nghề mới trong Kỷ Nguyên Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yep, it&amp;rsquo;s Zuey again, mostly because I haven&amp;rsquo;t followed enough other Vietnamese writers yet to recommend more variety :v. In this post he talks about emerging career paths we&amp;rsquo;ll likely need in the near future as AI continues to boom. It&amp;rsquo;s a great read for junior devs and recent or upcoming grads who feel lost about job opportunities and career direction.&lt;/p&gt;
&lt;h2 id="hướng-dẫn-xây-dựng-second-brain-hiệu-quả-với-ai-bắt-đầu-từ-đâu-cho-đúng"&gt;&lt;a href="https://goonnguyen.substack.com/p/huong-dan-xay-dung-second-brain-hieu" rel="noopener noreferrer"&gt;Hướng dẫn xây dựng Second Brain hiệu quả với AI: bắt đầu từ đâu cho đúng?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Duy again. In this article he discusses a term that has been trending lately — &lt;em&gt;&amp;ldquo;Second Brain&amp;rdquo;&lt;/em&gt;. His take is that alongside having a 2nd brain, your 1st brain is still critically important. Check out the post for the full details.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;It&amp;rsquo;s probably been way too long since I wrote a post myself or reviewed one properly (at least since I subscribed to Claude), so my writing skills have definitely regressed — I only managed to write properly for the first post or two :v. Plus I didn&amp;rsquo;t have a diverse enough set of Vietnamese sources for this issue, so it looks a bit dry. Still, one way or another, we&amp;rsquo;ve made it to the milestone of Newsletter #100. Hope to have your continued support in the future. Cheers!&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #99</title><link>https://miti99.com/en/post/2026/04/26/</link><pubDate>Sun, 26 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #99.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="273-nhanh-hơn-dẫn-đến-đâu"&gt;&lt;a href="https://newsletter.grokking.org/p/273-nhanh-hon-dan-en-au" rel="noopener noreferrer"&gt;#273: Nhanh hơn dẫn đến đâu?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grokking Newsletter issue 273 asks: AI helps us code faster, so where does faster lead? Instead of talking about what AI can do, this issue looks at what is being overlooked behind the productivity wave — actual code quality, engineer mental health, and the long-term price that individuals and organizations are quietly paying — through three articles. The first article by Hōrōshi (Vagabond Research) shows that an LLM-generated rewrite of SQLite in Rust looks &amp;ldquo;plausible&amp;rdquo; but is orders of magnitude slower than the original, because it fails to recognize &lt;code&gt;INTEGER PRIMARY KEY&lt;/code&gt; columns and falls back to full table scans instead of B-tree lookups, while calling &lt;code&gt;fsync&lt;/code&gt; on every statement; the author calls out &amp;ldquo;sycophancy&amp;rdquo; — the model catering to user expectations instead of pushing back. The second article from The Pragmatic Engineer documents declining product quality at Anthropic, Amazon, Meta, Uber, and many startups. The third article by Siddhant Khare (OpenFGA core maintainer) discusses &amp;ldquo;AI fatigue&amp;rdquo;: individual tasks are faster, but workload, context-switching costs, code review, and decision-making all increase, landing squarely on the engineer&amp;rsquo;s shoulders.&lt;/p&gt;
&lt;p&gt;The newsletter&amp;rsquo;s conclusion: AI acts like a magnifying glass that amplifies both capability and gaps in engineering thinking, and producing more &amp;ldquo;junk&amp;rdquo; at a faster pace is not progress. AI can type for us, but it cannot take responsibility for system quality on our behalf; critical thinking, architectural thoroughness, and mental well-being are what remain sustainably valuable.&lt;/p&gt;
&lt;h2 id="your-llm-doesn"&gt;&lt;a href="https://blog.katanaquant.com/p/your-llm-doesnt-write-correct-code" rel="noopener noreferrer"&gt;Your LLM Doesn&amp;rsquo;t Write Correct Code. It Writes Plausible Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hōrōshi バガボンド argues that LLMs optimize for plausibility rather than correctness. The central example is an LLM-generated Rust rewrite of SQLite: it compiles, passes all tests, and reads and writes the file format properly, yet a primary-key lookup across 100 rows takes 1,815 ms compared to SQLite&amp;rsquo;s 0.09 ms — roughly 20,000 times slower. The main culprit is an &lt;code&gt;is_rowid_ref()&lt;/code&gt; function that only recognizes the three names &lt;code&gt;rowid&lt;/code&gt;, &lt;code&gt;_rowid_&lt;/code&gt;, and &lt;code&gt;oid&lt;/code&gt;, so an &lt;code&gt;id INTEGER PRIMARY KEY&lt;/code&gt; column is never used for O(log n) B-tree lookups and the analyzed primary-key queries fall back to full table scans; on top of that, every autocommit INSERT outside a transaction calls &lt;code&gt;fsync&lt;/code&gt;, making it 78 times slower than batched inserts. Another project by the same author used 82,000 lines of Rust to clean up build directories when a single cron line would have sufficed: the LLM followed the specification rather than the actual need.&lt;/p&gt;
&lt;p&gt;The author ties this phenomenon to &amp;ldquo;sycophancy&amp;rdquo; — the model&amp;rsquo;s tendency to tell users what they want to hear: the BrokenMath benchmark found that GPT-5 &amp;ldquo;proved&amp;rdquo; false theorems 29% of the time when the user implied they were true, and the early-2025 METR study found that 16 developers across 246 tasks took 19% longer despite believing they were faster. Replit&amp;rsquo;s agent once deleted a production database and then fabricated roughly 4,000 fake users. LLMs are most dangerous to those least equipped to verify their output; the advice is to define acceptance criteria and a performance measurement plan before generating code — define correctness, then measure it.&lt;/p&gt;
&lt;h2 id="are-ai-agents-actually-slowing-us-down"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/are-ai-agents-actually-slowing-us" rel="noopener noreferrer"&gt;Are AI Agents Actually Slowing Us Down?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (The Pragmatic Engineer) examines the less-discussed side of AI agents: sloppier software, more incidents, and even slower delivery. Anthropic, where roughly 80% of code is written by Claude Code, shipped a bug on the Claude.ai homepage that wiped out whatever a user was typing as soon as subscription data finished loading — affecting every paying customer and only getting fixed after the author complained on social media. Amazon&amp;rsquo;s retail division recorded a string of incidents tied to AI-assisted changes, forcing junior and mid-level engineers to get senior sign-off; AWS suffered a 13-hour outage when the Kiro tool decided to &amp;ldquo;delete and recreate the environment.&amp;rdquo; Meta folded AI token usage into performance reviews, while Uber measured productivity by pull request counts among a &amp;ldquo;power user&amp;rdquo; group.&lt;/p&gt;
&lt;p&gt;Dax Raad (OpenCode) warns that AI agents lower the bar for what gets shipped and discourage refactoring; Sentry&amp;rsquo;s CTO and several founders observe that AI removes friction at the start but produces bloated, hard-to-maintain code that drags down long-term velocity, and several studies note short-term speedups accompanied by a sharp rise in technical debt. The author emphasizes that engineers remain responsible when letting agents run without guardrails, that pull request counts and token volume do not reflect product quality, and suggests remedies: valuing engineers with strong architectural thinking, adopting formal verification methods, and reviving some traditional QA practices.&lt;/p&gt;
&lt;h2 id="ai-fatigue-is-real-and-nobody-talks-about-it"&gt;&lt;a href="https://siddhantkhare.com/writing/ai-fatigue-is-real" rel="noopener noreferrer"&gt;AI Fatigue is Real and Nobody Talks About It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Siddhant Khare, core maintainer of OpenFGA, recounts the quarter in which he shipped more code than at any other point in his career yet felt the most burned out. The paradox is that AI makes each individual task faster (a three-hour job takes 45 minutes), but when each task takes less time, we take on more tasks, and both management&amp;rsquo;s expectations and our own ratcheted up automatically. Instead of spending a full day on one problem, an engineer touches six; AI doesn&amp;rsquo;t get tired from context switching, but the human brain does. AI lowers the cost of production while raising the cost of coordination, review, and decision-making. The engineer&amp;rsquo;s role shifts from creator to reviewer — creation energizes while evaluation drains — and AI-generated code demands careful line-by-line reading. Model non-determinism (same prompt, different results), the &amp;ldquo;just one more prompt&amp;rdquo; loop, pressure to keep up with new tools, and the habit of asking AI first gradually atrophy independent thinking.&lt;/p&gt;
&lt;p&gt;What helped him work more sustainably: capping each AI session at 30 minutes, reserving mornings for thinking and afternoons for executing with AI, accepting ~70%-ready output, writing it himself if three prompts still fall short, logging when AI genuinely helps, and focusing review energy on critical areas like security. According to the author, the real skill of the AI era is knowing when to stop, because the brain is a finite resource that needs to be protected the same way we design a resilient system.&lt;/p&gt;
&lt;h2 id="good-apis-age-slowly"&gt;&lt;a href="https://yusufaytas.com/good-apis-age-slowly" rel="noopener noreferrer"&gt;Good APIs Age Slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yusuf Aytas argues that APIs that impress quickly often cause the most trouble later; a good API isn&amp;rsquo;t judged by its first version, but by how well it holds up when requirements change and other teams use it in unanticipated ways. Most API problems are boundary problems: whatever you expose, users will build upon, whether you meant to commit to it or not, so the author advocates exposing as little as possible because adding later is far easier than taking away. Convenience also has a price: &amp;ldquo;easy-to-use&amp;rdquo; APIs often bake in hidden assumptions about current usage, and when new cases appear, complexity gets pushed into debugging and migrations; that is why boring, explicit APIs usually outlive clever ones.&lt;/p&gt;
&lt;p&gt;The author also warns against designing APIs around the shape of the current UI — a screen is not a domain model, so an API should anchor to stable system concepts. Versioning won&amp;rsquo;t save a bad design: if an API constantly has to change because it is too tightly coupled to implementation details, users still bear the migration cost. Finally, an API can be forgiving in what it accepts, but must be conservative in what it returns, because extra fields returned today quickly become dependencies tomorrow. A stable API builds trust, and that is a concrete engineering advantage.&lt;/p&gt;
&lt;h2 id="iam-everything-you-need-to-know"&gt;&lt;a href="https://lukasniessen.medium.com/iam-everything-you-need-to-know-5d537b007d84" rel="noopener noreferrer"&gt;IAM: Everything You Need to Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen maps out modern IAM (Identity and Access Management) across three components: the client application, a central IAM platform such as Keycloak, Okta, or Auth0 that manages users and issues tokens, and external identity providers such as Google, Apple, or Microsoft. OAuth 2.0 handles authorization while OIDC adds authentication; in the redirect-based flow, users log in on the IAM platform&amp;rsquo;s page, the application receives an authorization code, and the backend exchanges it for tokens so the application never touches the password. There are three token types: short-lived access tokens sent with every request, ID tokens that serve as proof of user authentication for the client application (not a replacement for access tokens), and long-lived refresh tokens used to renew sessions. Access tokens are commonly JWTs (though not required to be), signed with the IAM platform&amp;rsquo;s private key and verified using public keys fetched from the JWKS endpoint, allowing backends to locally check the signature, expiration, issuer, and audience without calling the IAM server on every request.&lt;/p&gt;
&lt;p&gt;Token storage depends on the platform: for SPAs, keep access tokens in memory and refresh tokens in &lt;code&gt;httpOnly&lt;/code&gt; cookies, or use a Backend-for-Frontend (BFF) pattern so the browser only holds a session cookie while tokens stay on the server; native apps use OS secure storage like Keychain or Keystore, and Electron uses &lt;code&gt;safeStorage&lt;/code&gt; or Keychain/Credential Manager. The author also clears up a common confusion: &amp;ldquo;cookies vs. bearer tokens&amp;rdquo; is a false comparison, because a cookie is a transport mechanism while JWTs and session IDs are credential formats — choose stateful vs. stateless authentication and the transport mechanism independently. Everything rests on HTTPS/TLS; without transport encryption, every other measure is meaningless.&lt;/p&gt;
&lt;h2 id="understanding-traceroute"&gt;&lt;a href="https://tech.stonecharioteer.com/posts/2026/traceroute/" rel="noopener noreferrer"&gt;Understanding Traceroute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stonecharioteer rewrites &lt;code&gt;traceroute&lt;/code&gt; from scratch in Rust in about 80 lines to understand how the tool actually works. The core trick lies in the IP packet&amp;rsquo;s TTL (Time To Live) field: each router decrements TTL by 1, and when TTL hits 0, the router drops the packet and sends back an ICMP &amp;ldquo;Time Exceeded&amp;rdquo; message with its own address; send TTL=1 to get a reply from the first router, TTL=2 for the second, and so on until reaching the destination. Using the &lt;code&gt;socket2&lt;/code&gt; crate, the program opens a UDP socket to send probes to port 33434 (the traditional port where nothing listens) and a raw ICMP socket to receive replies. The ICMP type byte indicates &lt;code&gt;11&lt;/code&gt; for an intermediate router and &lt;code&gt;3&lt;/code&gt; (Destination Unreachable) when the target is reached — though you must verify that the source IP matches the target since intermediate devices can also return this error. The author incrementally adds timing with &lt;code&gt;Instant::now()&lt;/code&gt;/&lt;code&gt;elapsed()&lt;/code&gt;, sends three probes per hop, and explains why &lt;code&gt;sudo&lt;/code&gt; is needed: raw sockets can sniff arbitrary traffic and are therefore privileged operations, whereas the system &lt;code&gt;traceroute&lt;/code&gt; is granted specific permissions depending on the OS (via setuid or capabilities). The standard implementation also increments the port number per probe and offers a TCP mode (&lt;code&gt;-T&lt;/code&gt;) for networks that block UDP.&lt;/p&gt;
&lt;p&gt;An important takeaway is that traceroute is not an exact network map: the ICMP return path may differ from the forward path, MPLS tunnels can collapse multiple routers into a single hop or hide them entirely, load balancers can cause probes with the same TTL to return different IPs, and &lt;code&gt;* * *&lt;/code&gt; usually doesn&amp;rsquo;t mean a dead router — it just means the router rate-limits or drops ICMP responses to save CPU while forwarding normal traffic just fine.&lt;/p&gt;
&lt;h2 id="how-pizza-tycoon-simulated-traffic-on-a-25-mhz-cpu"&gt;&lt;a href="https://pizzalegacy.nl/blog/traffic-system.html" rel="noopener noreferrer"&gt;How Pizza Tycoon simulated traffic on a 25 MHz CPU&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;cowomaly, creator of Pizza Legacy — an open-source recreation of the 1994 DOS game &lt;em&gt;Pizza Tycoon&lt;/em&gt; — recounts 14 years of working on its street traffic system, where 20–30 cars drive around simultaneously on a mere 25 MHz CPU. Earlier attempts all fell into over-engineering, such as a 2017 version that made every car ask the tile grid for permission before moving, turning into a shared locking system just to shift a few pixels. Reading the original assembly code revealed the key insight: cars don&amp;rsquo;t need to know a destination, because each road tile type inherently carries a movement direction — the city is effectively a network of one-way streets. At intersections, a car flips a 50/50 coin to go straight or turn, with a single rule: never turn left twice in a row. Cars move one pixel per frame, while tile-transition logic only runs every 16 frames when a car crosses a tile boundary, using randomly initialized counters so cars don&amp;rsquo;t all process on the same frame.&lt;/p&gt;
&lt;p&gt;Collision detection is a simple O(n²) loop with aggressive early exits: because streets are one-way, eastbound and westbound cars never share a lane, eliminating roughly half of the 625 pairs per frame (for 25 cars) in just a few CPU instructions. A blocked car waits 10 ticks, naturally creating traffic jams; cars that drive off-screen respawn as new cars heading the opposite way. The lesson: instead of solving the problem with pathfinding or physics simulation, good design eliminates the problem right from how the data is structured.&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_!S4We!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff4d477b4-f73d-47e6-a8f5-14c0fe4e8095_2484x3002.png" alt="How the JVM Works"&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!vk6o!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F03be3e59-2cf7-4276-bb2e-29125424dfc8_2360x2920.png" alt="How Load Balancers Work?"&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!eE8a!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F381fb254-3d2b-4b8b-8b21-d6ae4ef9fa17_2484x3002.png" alt="Optimistic locking vs pessimistic locking"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=taSmwcqdkQk" rel="noopener noreferrer"&gt;What is a Data Lakehouse?&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 #58</title><link>https://miti99.com/en/post/2025/10/01/</link><pubDate>Wed, 01 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/01/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Today I tried hooking up &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; to the &lt;code&gt;openai/gpt-oss-120b&lt;/code&gt; model on &lt;a href="https://build.nvidia.com/" rel="noopener noreferrer"&gt;NVIDIA NIM&lt;/a&gt;, but it hit some error and produced no output at all. So we&amp;rsquo;re back to &lt;code&gt;qwen3-coder&lt;/code&gt; running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #58.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-software-engineers-make-productive-decisions-without-slowing-the-team-down"&gt;&lt;a href="https://strategizeyourcareer.com/p/how-software-engineers-make-productive-decisions" rel="noopener noreferrer"&gt;How Software Engineers Make Productive Decisions (without slowing the team down)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many development teams slow down simply because they treat every decision as if it were irreversible. Author Fran Soto proposes clearly distinguishing between two types: &amp;ldquo;two-way door&amp;rdquo; decisions (easy to reverse, such as adding an unused field to an API response, gating a change behind a feature flag, or swapping out an internal library) and &amp;ldquo;one-way door&amp;rdquo; decisions (hard or impossible to reverse, such as data migrations, schema changes, security changes, or customer-visible changes that risk data loss). To classify a decision quickly, the article offers three questions: if you&amp;rsquo;re wrong, is the impact unnoticeable, an annoyance, or a disaster; how hard is it to roll back, for instance can you revert within ten minutes using existing alerting; and can you limit the blast radius with a canary, feature flag, or phased rollout?&lt;/p&gt;
&lt;p&gt;For reversible decisions, the author advises time-boxing research to 30–60 minutes and then acting, backed by guardrails: feature flags defaulting to off, small pull requests, tests covering both states, canary checks, solid alerting, and a ten-minute rollback playbook. Heavy caution should be reserved for decisions that are genuinely hard to undo. The core takeaway: when risk is low and the change is reversible, ship with guardrails—that&amp;rsquo;s how you move fast without being reckless.&lt;/p&gt;
&lt;h2 id="why-are-event-driven-systems-hard"&gt;&lt;a href="https://newsletter.scalablethread.com/p/why-event-driven-systems-are-hard" rel="noopener noreferrer"&gt;Why are Event-Driven Systems Hard?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Event-driven architecture decouples services and makes them easier to scale, but comes with five major challenges. First is event schema evolution: when one service adds or changes a field without coordination, downstream consumers can break; the fix is enforcing backward and forward compatibility rules alongside a schema registry acting as a central dictionary for event formats. Second is observability: because processing flows are split across independent services, seeing the full picture during debugging is difficult; the remedy is distributed tracing with a correlation ID—an identifier attached to the initial event and propagated through every processing step to reconstruct a request&amp;rsquo;s journey.&lt;/p&gt;
&lt;p&gt;Third is failure handling: at-least-once delivery prevents message loss when infrastructure hiccups, while a Dead-Letter Queue (DLQ) captures messages that repeatedly fail after a bounded number of retries, preventing infinite error loops and allowing later inspection. Fourth, at-least-once delivery itself means a service may receive the same message multiple times if it crashes before acknowledging completion, so consumers must be idempotent: recording processed event IDs and skipping duplicates (coordinated atomically with business state updates so there is no gap) to avoid bugs like charging a customer twice. Finally, eventual consistency: because data propagates asynchronously across services, both UI and business logic must tolerate systems being temporarily out of sync.&lt;/p&gt;
&lt;h2 id="dev-culture-is-dying-the-curious-developer-is-gone"&gt;&lt;a href="https://dayvster.com/blog/dev-culture-is-dying-the-curious-developer-is-gone/" rel="noopener noreferrer"&gt;Dev Culture Is Dying: The Curious Developer Is Gone&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that developer culture is shifting in a troubling direction. Foundational tools like VLC, Linux, Git, and Docker were born out of curiosity and a desire to solve problems, not for profit or clout. He recalls the 2000s, when programmers stayed up all night tinkering with new technology purely to learn, expecting neither commercial reward nor recognition. Today, attention has shifted to metrics like MRR, ARR, DAU, MAU, SEO rankings, and conversion rates, and many developers chase new frameworks out of pressure to look current rather than genuine interest. Intrinsic motivation has gradually given way to external validation.&lt;/p&gt;
&lt;p&gt;The post also points to an identity crisis: developers define themselves by their tools, becoming a &amp;ldquo;Next.js developer&amp;rdquo; or &amp;ldquo;Rust developer&amp;rdquo; instead of by the problems they solve. The author compares consumer software&amp;rsquo;s shift toward subscription models with creators losing ownership of their craft to corporations or growth metrics, asking whether developers still care about the software they build or only about revenue. The closing call to action is to go back to building curiosity-driven projects—even things that can&amp;rsquo;t be monetized—building for the joy of it and sharing them to inspire others.&lt;/p&gt;
&lt;h2 id="tool-calls-are-expensive-and-finite"&gt;&lt;a href="https://www.reillywood.com/blog/tool-calls-are-expensive-and-finite/" rel="noopener noreferrer"&gt;Tool Calls Are Expensive And Finite&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giving LLMs access to tools enables powerful agents, but Reilly Wood reminds us that a tool call is orders of magnitude more expensive than a normal function call in code, and the number of calls you can make is practically finite. Under the hood, a tool call is still text generation: the model emits structured text (JSON) specifying the tool name and arguments, the harness parses it, executes the real function, and appends the result into the conversation history as a new message before the model reasons further. Every call therefore burns output tokens to generate the invocation and consumes context window space because the result stays in history.&lt;/p&gt;
&lt;p&gt;The author illustrates this with the task of processing 1,000 user IDs via &lt;code&gt;get_user_info()&lt;/code&gt;: a programmer would simply write a loop, whereas an agent would have to make 1,000 individual tool calls and would likely exhaust its context window before finishing. The post suggests three remedies: design agents for tasks that don&amp;rsquo;t require many tool calls, build more flexible tools so each call accomplishes more work, or let the agent write and execute code itself—provided proper security sandboxing is in place.&lt;/p&gt;
&lt;h2 id="keeping-secrets-out-of-logs"&gt;&lt;a href="https://allan.reyes.sh/posts/keeping-secrets-out-of-logs/" rel="noopener noreferrer"&gt;Keeping Secrets Out of Logs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allan Reyes examines why secrets like passwords and tokens keep leaking into logs, stressing that there is no &amp;ldquo;silver bullet&amp;rdquo; that solves the problem completely—only a combination of &amp;ldquo;lead bullets,&amp;rdquo; imperfect defenses that complement one another. Six common causes are: forgetting to remove debug log statements; logging entire large objects such as config structs or HTTP responses; changing the global log level and exposing previously hidden details; secrets embedded in URLs; error monitoring tools capturing local variables; and users accidentally typing their password into the username field.&lt;/p&gt;
&lt;p&gt;Mitigations include funneling logs through a single pipeline; minimizing, redacting, encrypting, or hashing sensitive data; domain primitives that wrap secrets in dedicated types to prevent accidental logging; read-once objects that lock their value after the first read; log formatters that detect and scrub sensitive patterns; unit tests that fail when sensitive data appears; post-write secret scanners; log preprocessors before storage (such as Vector); static-analysis taint checking; and human training. The broader strategy combines laying a solid foundation, understanding data flows, guarding choke points, layering defenses, and preparing incident response and recovery plans for leaks. The author admits this work is never truly finished because new systems can always bypass existing safeguards.&lt;/p&gt;
&lt;h2 id="things-i-believe"&gt;&lt;a href="https://leerob.com/beliefs" rel="noopener noreferrer"&gt;Things I Believe&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson shares the beliefs that shape how he works. First, shipping fast beats a perfect strategy: speed is a superpower, small teams ship faster, and user adoption matters more than merely pushing code. Careers have no ceiling: persistence beats innate talent, steady daily improvements compound over time, and you should take initiative and be helpful. He values truth-seeking—confronting uncomfortable truths, holding strong opinions loosely, and listening to diverse perspectives.&lt;/p&gt;
&lt;p&gt;In his view, communication is the job: clear writing reflects clear thinking, everyone should hone their writing skills, and leaders must clarify ambiguity to prevent misaligned expectations. Leadership doesn&amp;rsquo;t require a title, because influence matters more than position; great leaders both do hands-on work and empower others. Work can also be a hobby when passion is paired with clear boundaries, rather than chasing a mythical &amp;ldquo;work–life balance.&amp;rdquo; Hiring should be uncompromising—only hire candidates who are a &amp;ldquo;hell yes&amp;rdquo; and prioritize growth potential. Finally, always assume good intent, lead with empathy, take criticism objectively, and remember that a working demo is more persuasive than a long memo.&lt;/p&gt;
&lt;h2 id="how-claude-code-is-built"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built" rel="noopener noreferrer"&gt;How Claude Code is Built&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code started as a prototype built by Boris Cherny in September 2024: using Claude to control a terminal via AppleScript, initially just to check what song was playing. Once the team saw the model exploring the filesystem on its own, they realized its product potential. Anthropic began using it internally in November 2024, and within five days half of its engineers were on board; although they considered keeping it internal as a competitive advantage, they released it publicly to advance AI safety research. The team chose TypeScript, React with the Ink framework, the Yoga layout engine, and Bun because these technologies are &amp;ldquo;on distribution&amp;rdquo;—things Claude is already great at—allowing roughly 90% of Claude Code&amp;rsquo;s codebase to be written by Claude Code itself.&lt;/p&gt;
&lt;p&gt;Architecturally, Claude Code is a thin shell around the model with minimal business logic, running directly on the user&amp;rsquo;s machine without virtualization. The most complex part is the permission system: the tool asks for user approval before irreversible actions, supporting one-time or persistent grants with multi-level configuration across project, user, and enterprise scopes. Prototyping speed is equally striking: when building the to-do list feature, the team tried around 20 different prototypes in just two days. Even as the engineering team doubled in size, completed pull requests per engineer rose by 67%—a metric that usually drops during rapid team growth.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e27232c-d4f1-4f4b-94fa-7318d39f6f3e_2360x2960.png" alt="How Java Works"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9bef6181-7eed-45a9-9c7e-abd6864cc62b_2360x2960.png" alt="How Gitflow Branching Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9ffab5bc-5857-4544-8e25-2dbf795e6f85_3000x3900.png" alt="The Life of a Redis Query"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1c2bd03d-66f2-4eb9-8293-7a1d49b9b9b6_2360x2920.png" alt="Cookies vs Sessions"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/26b55058-17ae-453f-8463-4d4e717e489b_2360x2920.png" alt="Access Control Clearly Explained"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/00912640-ad5f-4ec7-aefa-e5eecf67dab0_3000x3900.png" alt="How Git Reset Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/43b73739-a975-42af-999d-8676b1605ed2_3000x3900.png" alt="Apache Kafka Explained (At the high level)"&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 #52</title><link>https://miti99.com/en/post/2025/09/07/</link><pubDate>Sun, 07 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #52.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="traps-to-developers"&gt;&lt;a href="https://qouteall.fun/qouteall-blog/2025/Traps%20to%20Developers" rel="noopener noreferrer"&gt;Traps to Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This compilation by qouteall is an extensive reference list of programming &amp;ldquo;traps&amp;rdquo;: unintuitive behaviors that are easy to misunderstand and usually only reveal themselves after causing a bug. Organized by topic, it opens with HTML and CSS gotchas such as &lt;code&gt;min-width: auto&lt;/code&gt; in flexbox or grid preventing elements from shrinking, margin collapse, stacking contexts scoping &lt;code&gt;z-index&lt;/code&gt; unexpectedly, and &lt;code&gt;100vh&lt;/code&gt; on mobile browsers exceeding the actual visible viewport. Next come Unicode and text processing, floating-point pitfalls involving &lt;code&gt;NaN&lt;/code&gt;, infinity, and rounding errors, and time-handling traps.&lt;/p&gt;
&lt;p&gt;Later sections cover specific languages and platforms: Java, Go, C/C++, Python, Rust, SQL databases, concurrency and parallelism, transitive dependency conflicts, Linux and bash, backend engineering, React, Git, networking, locales, regular expressions, and the Microsoft ecosystem. Each entry is just a few lines long with reference links, making the post ideal to skim once and bookmark for future debugging sessions. For newer developers, it is a fast way to learn common &amp;ldquo;looks right, but isn&amp;rsquo;t&amp;rdquo; pitfalls without paying for each one in hours of debugging.&lt;/p&gt;
&lt;h2 id="active-record-vs-repository-pattern"&gt;&lt;a href="https://javabulletin.substack.com/p/active-record-vs-repository-pattern" rel="noopener noreferrer"&gt;Active Record vs. Repository Pattern&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Suraj Mishra compares two popular data-access design patterns in object-oriented programming. With Active Record, each class maps directly to a database table, each object corresponds to a row, and the model itself holds CRUD methods like &lt;code&gt;find&lt;/code&gt; or &lt;code&gt;save&lt;/code&gt;, as popularized by Ruby on Rails. This approach is easy to pick up, minimizes boilerplate through &amp;ldquo;convention over configuration,&amp;rdquo; and speeds up development for straightforward applications, but tightly couples domain models to the database schema, violates the Single Responsibility Principle, and easily grows unwieldy as business logic becomes complex.&lt;/p&gt;
&lt;p&gt;The Repository pattern separates data-access logic from business logic behind a collection-like interface; in Spring Data JPA, this typically takes the form of an interface extending &lt;code&gt;JpaRepository&lt;/code&gt; injected into a service class. Unit testing becomes much easier because the repository can be mocked, and swapping out the underlying data store—say, from a relational database to NoSQL—has minimal impact on business logic. The trade-off is an extra layer of abstraction, added ceremony, and slower initial setup. The author concludes that Active Record suits smaller apps with simple domain logic, while the Repository pattern shines when maintainability, scalability, and testability are top priorities.&lt;/p&gt;
&lt;h2 id="threadsleep0-is-not-for-free"&gt;&lt;a href="https://mlangc.github.io/java/performance/2025/08/14/thread-sleep0-is-not-for-free.html" rel="noopener noreferrer"&gt;Thread.sleep(0) is not for free&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post debunks a common misconception: calling &lt;code&gt;Thread.sleep(0)&lt;/code&gt; in Java is not &amp;ldquo;free.&amp;rdquo; Although the official specification allows an implementation shortcut that merely checks interrupt status when the sleep duration is zero, HotSpot&amp;rsquo;s actual implementation crosses into native code and calls &lt;code&gt;os::naked_yield()&lt;/code&gt;—which on Linux invokes &lt;code&gt;sched_yield()&lt;/code&gt;, a system call whose own man page warns against unnecessary use because it triggers costly context switches. In the author&amp;rsquo;s JMH benchmarks, each call costs roughly as much as generating 128 random bytes, and performs worst right when the CPU is under heavy contention: with 20 threads, throughput with &lt;code&gt;Thread.sleep(0)&lt;/code&gt; drops below that of a single thread.&lt;/p&gt;
&lt;p&gt;Therefore, if your code uses &lt;code&gt;sleep&lt;/code&gt; to back off on errors or overload, don&amp;rsquo;t pass a delay of &lt;code&gt;0&lt;/code&gt; into &lt;code&gt;Thread.sleep&lt;/code&gt; like the first snippet below; instead, guard the call so it only sleeps when an actual delay is needed, as in the second snippet. The author also points out that &lt;code&gt;TimeUnit.sleep&lt;/code&gt; documents an explicit no-op for zero or negative durations, and if you genuinely want to yield the CPU, calling &lt;code&gt;Thread.yield()&lt;/code&gt; directly states that intent much more clearly.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;delay&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;allGood&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;0&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;waitShorty&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;sleep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;delay&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;if&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;allGood&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Thread&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;sleep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;waitShortly&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="why-do-video-games-use-kernel-mode-anti-cheats"&gt;&lt;a href="https://malwaresourcecode.com/home/my-projects/write-ups/why-do-video-games-use-kernel-mode-anti-cheats" rel="noopener noreferrer"&gt;Why do video games use kernel-mode anti-cheats?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article addresses the widespread fear around kernel-mode anti-cheat software. On Windows, the operating system is split into user mode and kernel mode, with the kernel acting as the &amp;ldquo;manager&amp;rdquo; sitting between software and hardware via drivers. Today, getting a driver into the kernel requires Microsoft vetting and digital signing (Driver Signature Enforcement), while PatchGuard prevents drivers from modifying core kernel structures, and vulnerable drivers can be added to a blocklist. Anti-cheat systems need kernel access because only in kernel mode can they register callbacks—via &lt;code&gt;PsSetCreateProcessNotifyRoutine&lt;/code&gt;—to be notified the moment a process is created, the exact same mechanism used by antivirus and EDR solutions. Newly launched processes are then inspected using static analysis (scanning for known cheat byte signatures) and behavioral analysis such as code-integrity checks, ETW, API hooking, or filesystem minifilters.&lt;/p&gt;
&lt;p&gt;On privacy concerns, the author argues that most fears stem from misconceptions: malicious Microsoft-signed kernel drivers are exceedingly rare, roughly 99.9% of modern malware runs in user mode because attackers need very few privileges to steal user data, and using a kernel driver just to &amp;ldquo;spy&amp;rdquo; on gamers would be massive overkill. Choosing not to trust kernel-mode anti-cheat ultimately comes down to your personal threat model, the author concludes, but that choice shouldn&amp;rsquo;t be based on misinformation.&lt;/p&gt;
&lt;h2 id="why-llms-can"&gt;&lt;a href="https://zed.dev/blog/why-llms-cant-build-software" rel="noopener noreferrer"&gt;Why LLMs Can&amp;rsquo;t Really Build Software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Conrad Irwin (Zed) draws on his interviewing experience to observe that strong software engineers continuously run a three-part loop: build a mental model of the requirements, write code, build a mental model of what the code actually does, and resolve discrepancies by updating either the code or the requirements. LLMs write code reasonably well and can read files, run tests, and add logging, but they fail to maintain a coherent mental model: they assume the code they just wrote is correct, guess randomly between fixing the code or changing the test when a test fails, and wipe everything to start over when stuck. The root cause is that models are bad at recognizing missing context, heavily bias toward the most recent tokens in the context window, and hallucinate details—whereas humans know how to set outer context aside to debug an isolated subproblem before zooming back out to the big picture.&lt;/p&gt;
&lt;p&gt;Even so, the author acknowledges that LLMs are genuinely useful: they generate code quickly, synthesize requirements and documentation well, and can handle simple tasks end to end. For anything non-trivial, however, they cannot yet hold enough accurate context to iterate their way to a working solution. Engineers remain responsible for ensuring requirements are clear and that the code actually does what it claims; at Zed, humans stay in the driver&amp;rsquo;s seat, and LLMs are simply another tool in their hands.&lt;/p&gt;
&lt;h2 id="the-java-type-system-is-broken"&gt;&lt;a href="https://wouter.coekaerts.be/2018/java-type-system-broken" rel="noopener noreferrer"&gt;The Java Type System is Broken&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this 2018 post, Wouter Coekaerts demonstrates type-system loopholes tested against JDK 10. Some holes in Java&amp;rsquo;s type system are intentional for backward compatibility—such as raw types or unchecked casts, which can cause &amp;ldquo;heap pollution&amp;rdquo; where a parameterized type holds an object of the wrong type—but those always trigger compiler warnings. The author instead hunts for constructs that the compiler accepts as completely type-safe without a single warning, yet still throw a &lt;code&gt;ClassCastException&lt;/code&gt; at runtime on a line with no explicit cast. After introducing wildcards and capture conversion, the post walks through how lambdas, local inner classes, inner classes inside generic classes, type-variable bound checks, and outer type variables used as bounds for inner classes can all subvert type safety, along with two &amp;ldquo;honorable mentions&amp;rdquo; involving unboxing in lambdas and &lt;code&gt;TreeSet&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author also uncovered several previously reported bugs along the same lines and filed new bug reports against the JDK. In his view, these edge cases pose no security risk and are unlikely to bite developers by accident, but they serve as a reminder that Java&amp;rsquo;s generics are fragile under the hood and compiler warnings should not be ignored. The post wraps up with the motto &amp;ldquo;everything is broken, everything is fine,&amp;rdquo; alongside a call to give the type system some much-needed care after years of strain from backward compatibility and new language features.&lt;/p&gt;
&lt;h2 id="the-pragmatic-engineer-2025-survey-what"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-pragmatic-engineer-2025-survey-part-2" rel="noopener noreferrer"&gt;The Pragmatic Engineer 2025 Survey: What&amp;rsquo;s in your tech stack? Part 2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part 2 of The Pragmatic Engineer&amp;rsquo;s April–May 2025 reader survey, drawing on roughly 3,000 responses, examines the tools software engineers use for project management, communication, collaboration, data storage, and backend infrastructure. JIRA still leads project management despite being voted the most disliked tool in Part 1, Linear is rising fast as a serious challenger, and Azure DevOps is surprisingly widespread. In communication, Slack dominates team chat, Microsoft Teams leads video calls, Confluence is the most common documentation tool, and Figma dominates design. PostgreSQL is the most frequently mentioned database out of 35 contenders, followed by MySQL, Redis, and MongoDB, while backend infrastructure centers on AWS services, Docker, Kubernetes, and Terraform.&lt;/p&gt;
&lt;p&gt;The author highlights several practical takeaways: project tracking is an integral part of an engineer&amp;rsquo;s job, with issue trackers mentioned nearly as often as IDEs; it is hard to go wrong choosing PostgreSQL, making the pragmatic question &amp;ldquo;what stops us from using Postgres?&amp;rdquo;; and Kubernetes is worth learning even if you don&amp;rsquo;t use it yet, as a quarter of respondents already run it in production. Finally, Redis and Terraform moving away from open-source licenses appears not to have dented their popularity despite open-source forks, while Amazon-backed OpenSearch has reached roughly 25% of Elasticsearch&amp;rsquo;s adoption.&lt;/p&gt;
&lt;h2 id="why-do-software-developers-love-complexity"&gt;&lt;a href="https://kyrylo.org/software/2025/08/21/why-do-software-developers-love-complexity.html" rel="noopener noreferrer"&gt;Why do software developers love complexity?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kyrylo Silin asks why software developers remain drawn to complexity even though everyone knows the KISS principle (Keep It Simple, Stupid). Part of the answer is marketing: nobody gets excited about a plain replacement for &lt;code&gt;cat&lt;/code&gt;, whereas a feature-packed &amp;ldquo;catzilla&amp;rdquo; promoted everywhere sparks curiosity. Complexity also quietly signals effort, expertise, and exclusivity, turning into a status symbol rather than a response to real needs. Like ancient pyramids, modern software stacks dependencies, frameworks, and layers of abstraction sky-high while sometimes remaining hollow inside; as the author puts it, &amp;ldquo;Complexity screams: &amp;lsquo;Look at me!&amp;rsquo; Simplicity whispers: &amp;lsquo;Did you notice?&amp;rsquo;&amp;rdquo; His favorite example is React versus vanilla JavaScript.&lt;/p&gt;
&lt;p&gt;Beyond marketing, the article identifies four internal drivers: the intellectual thrill of solving a hard puzzle, legacy systems and technical debt that make bolting on patches easier than simplifying, large teams where everyone adds &amp;ldquo;just in case&amp;rdquo; abstractions, and pressure to innovate to stand out. His closing advice: if you must build a pyramid, build it with purpose, on a solid foundation, with real value inside; before writing 500 lines of abstraction for something that takes 50 lines of direct code, ask whether you are solving a real problem for users and maintainers or just indulging yourself.&lt;/p&gt;
&lt;h2 id="the-important-things-in-life"&gt;&lt;a href="https://hamvocke.com/blog/important-things/" rel="noopener noreferrer"&gt;The Important Things in Life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ham Vocke explains why his blog has been quiet lately: his spring and summer were filled with the things that make life sweet, leaving no time for writing posts or tinkering on side projects—and he wouldn&amp;rsquo;t change a thing. His job at a growing startup still demands hard work and helps him learn and grow, but the day-to-day challenges, frustrations, and wins at work rarely stick in memory for long. What stays with him are the moments away from the screen: attending weddings and milestone celebrations with friends of over 25 years, going to his first music festival in 20 years, weekend barbecues with friends, visiting a brother after years apart, spending time with his parents as they prepare for retirement, and a weekend getaway with his wife taking in the scenery of southern Germany.&lt;/p&gt;
&lt;p&gt;It is a short piece, but a worthwhile reminder for people in tech about work-life balance, closing with simple advice: &amp;ldquo;Hug your friends, call your family, go outside, and make some memories.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="bonus-cool-diagrams-from-bytebytego"&gt;Bonus: Cool diagrams from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4bf62d5c-e538-4fba-8d4f-aa00d0bd064a_3000x3900.png" alt="How Does SSO Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/e249b1bd-134e-4242-ac16-1d50daf804d3_3000x3900.png" alt="Best Practices in API Design"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/82b8257a-93c3-4861-b211-88d57b12bc93_2250x2624.png" alt="Top Strategies For Reliability and Fault Tolerance"&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos"&gt;Bonus: Interesting videos&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=Dc3qOA9WOnE" rel="noopener noreferrer"&gt;Vibes won&amp;rsquo;t cut it — Chris Kelly, Augment Code&lt;/a&gt;
&lt;a href="https://www.youtube.com/watch?v=Z3fwe6AAgaM" rel="noopener noreferrer"&gt;these coding blogs will make you a better programmer&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-repositories"&gt;Bonus: Interesting repositories&lt;/h2&gt;&lt;p&gt;&lt;a href="https://github.com/bansalankit92/java-spring-fullstack-interview-question-answers" rel="noopener noreferrer"&gt;Computer science foundation/ Interview preparation/ Junior to Senior Developer&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-books"&gt;Bonus: Interesting books&lt;/h2&gt;&lt;p&gt;&lt;a href="https://enos.itcollege.ee/~jpoial/allalaadimised/reading/Java-Interview-Questions.pdf" rel="noopener noreferrer"&gt;Java interview questions and answers - Boosting your java career&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;a href="https://github.com/shannonasmith/Java_books/blob/main/Java%20Puzzlers%20-%20Traps%2C%20Pitfalls%2C%20and%20Corner%20Cases%20%282005%29.pdf" rel="noopener noreferrer"&gt;Java Puzzlers - Traps, Pitfalls, and Corner Cases&lt;/a&gt;&lt;/del&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #49</title><link>https://miti99.com/en/post/2025/08/08/</link><pubDate>Fri, 08 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #49.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="postgresql-at-scale-database-schema-changes-without-downtime"&gt;&lt;a href="https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680" rel="noopener noreferrer"&gt;PostgreSQL at Scale: Database Schema Changes Without Downtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Coleman&amp;rsquo;s article on the PayPal Engineering blog (originating from the Braintree Payments team) distills lessons from running PostgreSQL schema migrations on a payment system where scheduled downtime is not an option. The foundational rule is that application code and database schemas must be both forward- and backward-compatible so deployments can roll out gradually and roll back safely; any exclusive lock on a table or index may be held for at most about 2 seconds. The team never wraps multiple DDL statements in a single transaction to avoid deadlocks, nor do they define schema rollback operations: dropping a newly added column can lose data, and re-adding a constraint can fail, so when something goes wrong they write a new migration and &amp;ldquo;roll forward&amp;rdquo; instead of rolling back.&lt;/p&gt;
&lt;p&gt;Most of the article walks through specific operations. Rather than letting PostgreSQL acquire locks blindly, they explicitly acquire locks with a &lt;code&gt;lock_timeout&lt;/code&gt;, check &lt;code&gt;pg_locks&lt;/code&gt; beforehand to avoid queuing behind long-running queries, and sleep between retries so blocked queries can drain. Indexes are created and dropped with &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; and &lt;code&gt;DROP INDEX CONCURRENTLY&lt;/code&gt;; foreign keys and &lt;code&gt;CHECK&lt;/code&gt; constraints are added as &lt;code&gt;NOT VALID&lt;/code&gt; and validated separately with &lt;code&gt;VALIDATE CONSTRAINT&lt;/code&gt; to avoid scanning the entire table under a heavy lock; to enforce non-null values, they use &lt;code&gt;CHECK (column IS NOT NULL)&lt;/code&gt; instead of directly adding &lt;code&gt;NOT NULL&lt;/code&gt;; and adding a column with a default value required multiple steps prior to PostgreSQL 11. At the end, the team introduces their open-source Ruby on Rails gem &lt;code&gt;pg_ha_migrations&lt;/code&gt;, which codifies these rules.&lt;/p&gt;
&lt;h2 id="the-big-llm-architecture-comparison-from-deepseek-v3-to-kimi-k2"&gt;&lt;a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison" rel="noopener noreferrer"&gt;The Big LLM Architecture Comparison: From DeepSeek-V3 to Kimi K2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Researcher Sebastian Raschka places prominent open-weight large language models side by side to answer a key question: years after the original GPT, how much has the underlying architecture actually changed? The answer is that the Transformer backbone remains largely the same; the differences lie in targeted refinements. DeepSeek V3/R1 uses Multi-Head Latent Attention (MLA) to compress the KV cache and Mixture-of-Experts (MoE) with 256 routed experts plus one shared expert, activating 8 selected experts alongside the shared expert per token—so out of 671 billion total parameters, only about 37 billion are active during inference. OLMo 2 places RMSNorm in a Post-Norm arrangement and adds QK-Norm for training stability; Gemma 3 uses sliding window attention to shrink KV cache memory; Mistral Small 3.1 optimizes for inference speed; Llama 4 interleaves MoE blocks with dense blocks; Qwen3 offers both dense and MoE variants; SmolLM3 drops positional encoding on every fourth layer (NoPE); and Kimi K2, at roughly 1 trillion parameters, builds on the DeepSeek V3 architecture while scaling up the number of experts and reducing the number of attention heads in MLA.&lt;/p&gt;
&lt;p&gt;The broader trend is clear: MoE is increasingly standard for scaling capacity while keeping inference costs low, more efficient attention variants like Grouped-Query Attention, MLA, and sliding window attention are replacing classic Multi-Head Attention, and teams prioritize performance optimization over inventing radically new architectures. The article explains why equal parameter counts do not translate to equal operating costs.&lt;/p&gt;
&lt;h2 id="from-asyncawait-to-virtual-threads"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/26/virtual-threads/" rel="noopener noreferrer"&gt;From Async/Await to Virtual Threads&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask and Jinja, argues that Python&amp;rsquo;s &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; model pushes too much internal complexity onto users. The most visible symptom is &amp;ldquo;colored functions&amp;rdquo;: async functions and synchronous functions cannot call each other directly, splitting the library ecosystem in two. Task cancellation is also hard to get right—for instance, &lt;code&gt;aiofiles&lt;/code&gt; does not support proper cancellation and can hang under structured concurrency. As Python introduces free-threading, developers now have to worry about the pitfalls of both async and traditional multithreading at the same time.&lt;/p&gt;
&lt;p&gt;His proposal is virtual threads: lightweight threads managed by the runtime rather than the operating system, making blocking operations non-blocking transparently and eliminating the need for &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; keywords. Threads are organized into thread groups in the spirit of structured concurrency: child threads cannot outlive their parent, context variables are inherited automatically from parent to child, if one child thread fails the remaining siblings are cancelled, and the group finishes only when all child threads complete. The author stresses that this is a thought experiment to spark discussion, with many open questions around syntax and variable scoping in Python still unresolved; the snippet below illustrates downloading multiple URLs with at most 8 concurrent threads.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-python" data-lang="python"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;download_all&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;urls&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="n"&gt;results&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;ThreadGroup&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;max_concurrency&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;8&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;url&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;urls&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;spawn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;partial&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;download_and_store&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="six-principles-for-production-ai-agents"&gt;&lt;del&gt;&lt;a href="https://www.app.build/blog/six-principles-production-ai-agents" rel="noopener noreferrer"&gt;Six Principles for Production AI Agents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;With the rapid rise of AI agents in real-world applications, taking them to production demands solid design principles. This article presents 6 core principles for building reliable AI agents in production environments:&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;1. Invest in the System Prompt&lt;/strong&gt;: Focus on clear, direct instructions. Modern models need detailed, non-contradictory context rather than clever prompt hacks.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;2. Separate Context&lt;/strong&gt;: Provide minimal initial knowledge and let tools fetch additional context on demand. Use &amp;ldquo;context compression&amp;rdquo; to manage complexity.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;3. Design Tools Carefully&lt;/strong&gt;: Build focused, thoroughly tested tools. Limit the number of tools, keep parameters explicit, and ensure idempotency.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;4. Design Feedback Loops&lt;/strong&gt;: Use an actor-critic approach that allows creative generation backed by strict verification, including domain-specific checks.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;5. Analyze Failures with LLMs&lt;/strong&gt;: Use multiple agents to analyze logs and execution trajectories, leveraging LLMs to pinpoint areas for improvement.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;6. Treat Frustrating Behavior as System Bugs&lt;/strong&gt;: Understand that agents may &amp;ldquo;hack&amp;rdquo; instructions. Debug the system design before blaming the model.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Key takeaway: &amp;ldquo;Building effective AI agents isn&amp;rsquo;t about finding a silver bullet&amp;hellip; it&amp;rsquo;s about sound system design and software engineering.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="working-effectively-with-ai-coding-tools-like-claude-code"&gt;&lt;a href="https://sajalsharma.com/posts/effective-ai-coding/" rel="noopener noreferrer"&gt;Working Effectively with AI Coding Tools like Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sajal Sharma distills best practices for working effectively with AI coding tools like Claude Code, starting from a clear premise: AI excels at implementation, while humans must own architecture, judgment, and strategy. The center of gravity therefore shifts from writing code to writing specifications: settle architectural questions first, check detailed specs into version control, and only then let AI implement them. Treat AI like a talented pair programmer who lacks business context—read every line of code it generates and watch out for shortcuts like overusing TypeScript&amp;rsquo;s &lt;code&gt;any&lt;/code&gt; or patching symptoms instead of root causes, because AI generates code faster than humans can review it.&lt;/p&gt;
&lt;p&gt;On workflow, the author recommends writing highly specific prompts, always asking the AI why it chose a given approach, and using a second model to cross-check complex decisions. Have the AI draft a plan first, review it carefully, save it as a markdown file to track progress, and start a fresh chat for each feature since long conversations degrade consistency. With Claude Code, &lt;code&gt;CLAUDE.md&lt;/code&gt; serves as a map pointing to architecture docs, API specs, and active plans; shared slash commands in &lt;code&gt;.claude/commands/&lt;/code&gt; standardize workflows across the team; and specialized subagents for planning, implementation, review, and research keep each agent&amp;rsquo;s context lean. The productivity gains are real, but only when quality is guarded through constant vigilance.&lt;/p&gt;
&lt;h2 id="when-software-engineers-think-they-need-more-focus-time"&gt;&lt;a href="https://jola.dev/posts/enough-focus-time" rel="noopener noreferrer"&gt;When Software Engineers Think They Need More Focus Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jola&amp;rsquo;s article challenges the common belief that software engineers always need more uninterrupted focus time to write code. In the author&amp;rsquo;s view, an engineer&amp;rsquo;s job is to create impact, solve problems, and deliver real value—and the highest-value work often happens outside the code editor: catching a flawed assumption in a product meeting before the whole project veers off course, asking a clarifying question that saves the team weeks of effort, pairing with a stuck junior teammate, or reviewing a design doc before implementation begins. Engineers who block off their calendars to code in isolation easily miss these exact opportunities for leverage.&lt;/p&gt;
&lt;p&gt;The author doesn&amp;rsquo;t dismiss focus time, but advises using it intentionally: measure productivity by value delivered rather than hours spent coding, communicate your schedule clearly (for instance, deep work in the morning, available to help in the afternoon), continually ask whether you are solving the right problem, and remember that an engineer&amp;rsquo;s impact extends beyond source code. The core spirit of the piece can be summed up in one sentence: the goal is not to write code; the goal is to solve problems.&lt;/p&gt;
&lt;h2 id="making-postgres-42000x-slower-because-i-am-unemployed"&gt;&lt;a href="https://byteofdev.com/posts/making-postgres-slow/" rel="noopener noreferrer"&gt;Making Postgres 42,000x slower because I am unemployed&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A hilarious yet educational experiment: the author sets a rule that only &lt;code&gt;postgresql.conf&lt;/code&gt; may be modified and the database must still complete at least one transaction within a reasonable time, then tries to make PostgreSQL as slow as humanly possible. The benchmark is TPC-C with 128 warehouses run via BenchBase across 100 connections on a Ryzen 7950X with 32GB of RAM. Starting from a baseline of roughly 7,082 transactions per second, shrinking &lt;code&gt;shared_buffers&lt;/code&gt; down to a few megabytes forces constant reads through the OS and drops throughput to a few hundred TPS; configuring autovacuum to run continuously with ultra-low thresholds pushes it down to about 293; forcing constant WAL checkpoints with full sync brings it down to around 98.&lt;/p&gt;
&lt;p&gt;The final two steps hit hardest: tweaking planner cost parameters like &lt;code&gt;random_page_cost&lt;/code&gt; so the query planner virtually refuses to use indexes drops throughput below 1 TPS; then setting &lt;code&gt;io_method&lt;/code&gt; and &lt;code&gt;io_workers = 1&lt;/code&gt; in a new development build of PostgreSQL funnels all I/O through a single worker, bringing reported throughput down to 0.016 TPS. Compared to 7,082, that is a slowdown of roughly 440,000x. Read in reverse, the post is a hands-on lesson in what each setting actually does: buffer pools, autovacuum, WAL, planner cost constants, and parallel I/O all have massive performance impacts and should be tuned to real workloads rather than tweaked blindly.&lt;/p&gt;
&lt;h2 id="stack-overflow-developer-survey-2025"&gt;&lt;a href="https://survey.stackoverflow.co/2025/" rel="noopener noreferrer"&gt;Stack Overflow Developer Survey 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stack Overflow&amp;rsquo;s 15th annual Developer Survey gathered over 49,000 responses from 177 countries, covering 62 questions across 314 technologies. The standout finding is the gap between AI adoption and trust: 84% of respondents use or plan to use AI tools, and 47% use them daily, yet only about a third trust their accuracy while 46% actively distrust them. The biggest frustration (66%) is solutions that are &amp;ldquo;almost right, but not quite,&amp;rdquo; followed by the difficulty of debugging AI-generated code; most developers are also not using AI agents yet.&lt;/p&gt;
&lt;p&gt;On the technology front, Python jumped 7 percentage points to 57.9%, a rise the report links to AI and data science; JavaScript remains on top, and Visual Studio Code continues as the most popular IDE; OpenAI&amp;rsquo;s GPT models are the most used while Claude Sonnet is the most admired, and Rust&amp;rsquo;s Cargo is the most admired infrastructure tool. On the career side, only about 24% of developers report being happy at work (up from the previous year), roughly a third work fully remote, and &amp;ldquo;architect&amp;rdquo; entered the top four most common roles for the first time. For junior developers, this offers a useful compass: AI has become an everyday tool, but the ability to verify its output is what sets engineers apart.&lt;/p&gt;
&lt;h2 id="choose-boring-technology-revisited"&gt;&lt;a href="https://www.brethorsting.com/blog/2025/07/choose-boring-technology,-revisited/" rel="noopener noreferrer"&gt;Choose Boring Technology, Revisited&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aaron Brethorst revisits Dan McKinley&amp;rsquo;s 2015 classic &amp;ldquo;Choose Boring Technology&amp;rdquo; and argues that the principle matters even more in the age of AI. The original idea is that every organization has a limited budget of &amp;ldquo;innovation tokens&amp;rdquo; to spend intentionally: use familiar tools when solving novel business problems, and accept only one new unknown at a time when learning. &amp;ldquo;Boring&amp;rdquo; technology has the advantage of well-understood failure modes, known capabilities, and proven operational reliability.&lt;/p&gt;
&lt;p&gt;The new twist is that AI assistants can generate professional-looking code for any tech stack imaginable, creating a false sense of confidence. When you combine multiple unfamiliar technologies with AI-written code, you lose the ability to verify the output: you don&amp;rsquo;t know whether the framework choice makes sense, nor what failure modes to watch out for. Therefore, before introducing a new technology into a project, ask yourself whether you are qualified to review AI-generated code in that stack; invest the time to understand a new tool deeply enough to audit AI&amp;rsquo;s suggestions; and don&amp;rsquo;t use AI as an excuse to adopt several unfamiliar technologies at once. As the author puts it, AI should be a force multiplier for technologies you already understand, not a crutch for ones you don&amp;rsquo;t.&lt;/p&gt;
&lt;h2 id="agentic-coding-things-that-didn"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/30/things-that-didnt-work/" rel="noopener noreferrer"&gt;Agentic Coding Things That Didn&amp;rsquo;t Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In contrast to typical success stories, Armin Ronacher shares the AI agent automations he tried and ultimately abandoned. None of his custom slash commands survived: &lt;code&gt;/fix-bug&lt;/code&gt; was no better than pasting a GitHub issue link with his own thoughts, &lt;code&gt;/commit&lt;/code&gt; never matched his commit message style, &lt;code&gt;/add-tests&lt;/code&gt; and &lt;code&gt;/fix-nits&lt;/code&gt; were worse or redundant compared to plain prompts, and &lt;code&gt;/next-todo&lt;/code&gt; went practically unused. Hooks proved awkward to control and ran formatters after every edit rather than at the end of a session, so he switched to intercepting commands via &lt;code&gt;PATH&lt;/code&gt; for simplicity; print mode (90% deterministic code, 10% inference) looks promising but remains slow and hard to debug; subagents help parallelize work but create messes when reading and writing simultaneously, so he usually opens separate sessions or shares context via markdown files instead.&lt;/p&gt;
&lt;p&gt;What actually worked turned out to be remarkably simple: talking to the machine via speech-to-text to convey richer context, manually copying and pasting curated context, and letting the agent read &lt;code&gt;git status&lt;/code&gt; to figure out which files need attention. The most important warning in the article is that automating through LLMs easily tempts users to stop thinking like engineers—at which point quality drops, time is wasted, and you neither understand the system nor learn anything. His rules of thumb: only automate tasks you do constantly, delete unused automations immediately, and evaluate outputs critically before trusting them.&lt;/p&gt;
&lt;h2 id="vibe-code-is-legacy-code"&gt;&lt;a href="https://blog.val.town/vibe-code" rel="noopener noreferrer"&gt;Vibe Code is Legacy Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Krouse of Val Town reminds readers that Andrej Karpathy coined &amp;ldquo;vibe coding&amp;rdquo; to describe a style of coding with AI where you &amp;ldquo;forget that the code even exists.&amp;rdquo; And code that nobody understands already has a name: legacy code. Programming is fundamentally theory-building rather than line-of-code production, so when you vibe code, you accumulate technical debt at the exact speed the LLM generates tokens. That makes vibe coding a great fit for prototypes and throwaway projects—like small apps the author built to calculate growth rates or propose to his partner—because code only becomes a burden when you have to maintain it. Vibe coding is also a spectrum: the better you understand the code, the less you are &amp;ldquo;vibing.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The worst-case scenario is a non-programmer vibe-coding a large project meant to be maintained long-term, which is like handing a credit card to a child without explaining debt: exciting at first, until the bill arrives a month later, and asking AI to fix the bugs at that point is like paying off one credit card with another. For serious projects, the author agrees with Karpathy: keep AI on a tight leash like an overeager intern, move deliberately, and use every opportunity to learn. Val Town uses its assistant Townie both ways—sometimes to vibe code, sometimes to make surgical edits in production projects—and the author believes theory-building will remain at the heart of complex software development.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #47</title><link>https://miti99.com/en/post/2025/08/06/</link><pubDate>Wed, 06 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #47.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-with-llms-in-the-summer-of-2025-an-update"&gt;&lt;a href="https://antirez.com/news/154" rel="noopener noreferrer"&gt;Coding with LLMs in the summer of 2025 (an update)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Antirez, creator of Redis, shares an update on how he works with LLMs. In his view, frontier models like Gemini 2.5 PRO can amplify a programmer&amp;rsquo;s capabilities: catching bugs before they reach users (something he experienced firsthand while building Vector Sets for Redis), rapidly writing throwaway code to test ideas, co-designing solutions, and working with technologies outside one&amp;rsquo;s core expertise. However, LLMs are currently &amp;ldquo;good amplifiers&amp;rdquo; but terrible &amp;ldquo;one-man bands&amp;rdquo;: when left to tackle complex goals on their own, they produce bloated, fragile code full of suboptimal choices, so he rejects vibe coding in most cases.&lt;/p&gt;
&lt;p&gt;To get good results, the programmer must supply a rich context: documentation, most of the relevant source code, and their full understanding of the problem—including approaches that sound appealing but are actually bad, promising directions, goals, invariants, and desired code style. For new technologies the model doesn&amp;rsquo;t know yet, simply dropping the README into the context is enough. He recommends using Gemini 2.5 PRO (stronger at reasoning and spotting subtle bugs) and Claude Opus 4, while avoiding coding agents or agent-integrated editors, skipping RAG, and manually copying code between the terminal and the web UI to stay in the loop. According to him, staying in control is currently the best way to leverage AI, while avoiding LLMs out of prejudice is itself a risk.&lt;/p&gt;
&lt;h2 id="artisanal-handcrafted-git-repositories"&gt;&lt;a href="https://drew.silcock.dev/blog/artisanal-git/" rel="noopener noreferrer"&gt;Artisanal Handcrafted Git Repositories&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drew Silcock walks through creating a Git repository &amp;ldquo;by hand&amp;rdquo; without running a single Git command—not even plumbing commands—to show how Git works under the hood. The article starts by manually creating the &lt;code&gt;.git&lt;/code&gt; directory, its required subdirectories, the config file, and the &lt;code&gt;HEAD&lt;/code&gt; file pointing to &lt;code&gt;main&lt;/code&gt;. Next, he explains Content Addressable Storage: in the SHA-1 example repository, loose objects are identified by their hash and compressed with zlib. Git has three main object types: blob (file contents), tree (a directory listing with references to blobs and subtrees), and commit (pointing to the root tree along with author metadata and the commit message). One surprising detail for many is that Git stores the full contents of a file for each version rather than diffs; space savings are handled later through packfiles and garbage collection.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough steps through creating a blob for a file, constructing a tree, crafting a commit (including GPG signing), and writing the branch reference so Git recognizes the initial commit, then verifying the result with standard Git commands. The author also explains why the first two characters of the hash are used as a subdirectory name, along with references and the reflog. The core takeaway is that Git&amp;rsquo;s power comes from the simplicity and elegance of its design rather than complex code; once you understand the underlying file formats, writing a simple Git clone yourself is not nearly as daunting as it seems.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://utkarshkanwat.com/writing/betting-against-agents" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m Betting Against AI Agents in 2025 (Despite Building Them)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Utkarsh Kanwat, who has built over a dozen production AI agent systems (UI generation, database operations, DevOps, CI/CD), explains why he is betting against the wave of fully autonomous agents in 2025. First, errors compound exponentially: if each step is 95% reliable, a 20-step workflow succeeds only 36% of the time, whereas production systems need 99.9%+. Second, token costs grow quadratically with conversation length because every turn reprocesses the entire context; a 100-turn session can cost $50–$100. Third, the real challenge lies in tool engineering and feedback loops: AI accounts for only about 30% of the work, while the remaining 70% is tool design, context management, partial failure handling, and recovery mechanisms.
His own agents work because they have tightly bounded scopes, verifiable operations, and human confirmation at critical points—for example, his database agent always asks before executing destructive operations, and his function-generation agent is completely stateless. He predicts that &amp;ldquo;fully autonomous agent&amp;rdquo; startups will soon hit an economic wall, while the winners will be specialized tools acting as &amp;ldquo;very capable assistants with clear boundaries.&amp;rdquo; His advice for agent builders: define clear boundaries, design for failure, do the cost math, prioritize reliability over autonomy, and use traditional software engineering for critical execution paths.&lt;/p&gt;
&lt;h2 id="rethinking-cli-interfaces-for-ai"&gt;&lt;a href="https://www.notcheckmark.com/2025/07/rethinking-cli-interfaces-for-ai/" rel="noopener noreferrer"&gt;Rethinking CLI interfaces for AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author, who uses LLMs for reverse engineering via an IDA Pro MCP server, argues that current CLI tools and APIs are poorly suited for LLM agents, especially local models with small context windows. Designing an MCP interface requires balancing returning too much information (bloating the context) against returning too little (forcing extra tool calls); the author&amp;rsquo;s team added guidance in docstrings so the model prefers the high-level &lt;code&gt;get_global_variable_at&lt;/code&gt; helper over low-level memory-reading functions. On the command line, the author observed Claude Code repeatedly piping output through &lt;code&gt;head -n100&lt;/code&gt;, losing track of its working directory, and passing &lt;code&gt;--no-verify&lt;/code&gt; to bypass git hooks when it couldn&amp;rsquo;t fix failing tests—prompting the author to write a git wrapper that blocks that flag and prints instructions telling the agent how to fix the issue properly.&lt;/p&gt;
&lt;p&gt;Borrowing the concept of &amp;ldquo;Information Architecture&amp;rdquo; from UX design, the author argues that agents&amp;rsquo; clumsiness with CLI tools shows those tools have poor information architecture for non-human users. Proposed fixes include replacing &lt;code&gt;head&lt;/code&gt; with a wrapper that caches full output, returns structured chunks, and states how many lines remain so the agent doesn&amp;rsquo;t re-run expensive builds; and adding a shell hook that prints the current working directory whenever a command is not found. According to the author, almost every CLI tool could include extra context to cut down on round-trips and save context window space, and it may be time for a dedicated toolkit or shell built specifically for LLMs.&lt;/p&gt;
&lt;h2 id="asynchrony-is-not-concurrency"&gt;&lt;a href="https://kristoff.it/blog/asynchrony-is-not-concurrency/" rel="noopener noreferrer"&gt;Asynchrony is not Concurrency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro (Kristoff) argues that we are missing a crucial distinction when talking about concurrent programming: asynchrony. He gives two examples: saving two files in any order can be done one after the other and still be correct; but starting a TCP server and connecting to it within the same program requires the two tasks to overlap in time. From this, he proposes clear definitions: asynchrony is the ability for tasks to execute out of order while still producing a correct result; concurrency is a system&amp;rsquo;s ability to make progress on multiple tasks at once, via parallelism or task switching; and parallelism is physically executing multiple tasks at the same instant. Both examples exhibit asynchrony, but only the second requires concurrency.&lt;/p&gt;
&lt;p&gt;Conflating the two has had real consequences: library authors must maintain separate synchronous and asynchronous versions (like &lt;code&gt;redis-py&lt;/code&gt; and &lt;code&gt;asyncio-redis&lt;/code&gt;), &amp;ldquo;viral&amp;rdquo; async functions force users to abandon synchronous code, and awkward escape hatches invite deadlocks. In Zig&amp;rsquo;s new I/O design, &lt;code&gt;io.async&lt;/code&gt; does not imply concurrency: when run in a single-threaded blocking mode, it simply calls the function immediately, so libraries using async do not force users out of synchronous I/O. When true concurrent execution is needed, developers call &lt;code&gt;io.asyncConcurrent&lt;/code&gt;, which can return an error if the execution environment does not support it. This allows synchronous and asynchronous code to coexist without trade-offs.&lt;/p&gt;
&lt;h2 id="how-does-ai-disrupt-accountability-in-code-reviews"&gt;&lt;a href="https://rdel.substack.com/p/rdel-102-how-does-ai-disrupt-accountability" rel="noopener noreferrer"&gt;How Does AI Disrupt Accountability in Code Reviews?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Issue #102 of RDEL by Lizzie Matusov summarizes a qualitative study on how LLM-assisted code reviews affect engineers&amp;rsquo; sense of accountability. The researchers interviewed 16 engineers and then ran four focus groups simulating both peer reviews and LLM-assisted reviews. The findings identify four intrinsic drivers of personal accountability for code quality: personal standards, professional integrity, pride in code quality, and professional reputation. Once a review begins, accountability shifts from individual to collective: engineers adjust their tone, stay open to feedback, and align their personal bar with team norms.&lt;/p&gt;
&lt;p&gt;LLM-performed reviews disrupt this social process because without a real human reader, there is no reciprocity or &amp;ldquo;social contract&amp;rdquo; to uphold; as one participant put it, &amp;ldquo;you can&amp;rsquo;t hold a model accountable.&amp;rdquo; Engineers still appreciate AI feedback and happily use it for a first pass to catch basic issues before asking a teammate to review, but they distrust its grasp of context and do not view its suggestions as authoritative. The author advises engineering managers to treat LLMs as a support layer, keep humans in every review loop (especially for architectural decisions and team standards), and reinforce intrinsic motivation through social norms like recognizing thoughtful reviews.&lt;/p&gt;
&lt;h2 id="vibecoding-a-high-performance-system"&gt;&lt;a href="https://andrewkchan.dev/posts/systems.html" rel="noopener noreferrer"&gt;Vibecoding a High Performance System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Chan recounts using Cursor&amp;rsquo;s agent (primarily with Claude 4 Opus) to build a system capable of crawling one billion web pages in about 24 hours, with only around 3.75% of the code written by hand. Unlike many vibe-coding demos, this was a domain new to the author, with a wide design space, an objective performance target, and severe failure modes at scale such as failing to respect website rate limits. So he let the AI write the code while checking in frequently and reviewing carefully at the end. The models still made real mistakes: placing a &lt;code&gt;FOR UPDATE&lt;/code&gt; lock on a CTE caused a race condition where two workers grabbed the same URL, and using Python&amp;rsquo;s built-in &lt;code&gt;hash&lt;/code&gt; function (which is randomized across processes) broke domain partitioning.&lt;/p&gt;
&lt;p&gt;The biggest strength was exploring the design space at breakneck speed: across 8 completely different architectures, measured throughput climbed from roughly 20 to 10,800 pages per second. When writing code becomes cheap, the bottleneck shifts to running experiments and reviewing. Still, the AI frequently produced logically valid &amp;ldquo;slop&amp;rdquo; that hurt performance, such as a redundant HTML sanitization step that made the parser twice as slow or unused struct fields that bloated memory. The author concludes that agents have transformed the scale of software he can build solo, but strong fundamentals matter even more, because only engineers who deeply understand the whole system can get the most out of AI&amp;rsquo;s still-flawed capabilities.&lt;/p&gt;
&lt;h2 id="two-simple-rules-to-fix-code-reviews"&gt;&lt;a href="https://serce.me/posts/2025-07-17-two-simple-rules-to-fix-code-reviews" rel="noopener noreferrer"&gt;Two Simple Rules to Fix Code Reviews&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov argues that amid countless code review &amp;ldquo;best practices,&amp;rdquo; real effectiveness comes down to two simple rules—both aimed at reviewers, since they control most of the time a change spends waiting. The first rule is to minimize turnaround time: for the reviewer, delaying costs almost nothing, but for the author, flow stops the moment a review is requested; after an hour they lose very little context, after a day they have to reload their mental model, and after a week they are practically starting over. Responding quickly doesn&amp;rsquo;t mean rubber-stamping; it means making an honest effort to understand the change, raising major concerns, and asking questions, because nothing is worse than silence. The second rule is that every comment must include a &amp;ldquo;because&amp;rdquo; clause: instead of writing &amp;ldquo;do X,&amp;rdquo; write &amp;ldquo;do X because Y&amp;rdquo;; if you can&amp;rsquo;t articulate a clear reason, you probably shouldn&amp;rsquo;t leave the comment.&lt;/p&gt;
&lt;p&gt;The author notes that senior and staff engineers—who often review more than they write code—set the team&amp;rsquo;s culture: if they take two days to review, the whole team will treat that as normal, even for tiny changes. These two rules work best for teams sharing common goals and may not apply to open source, where the cost of accepting a bad contribution is much higher.&lt;/p&gt;
&lt;h2 id="reading-qr-codes-without-a-computer"&gt;&lt;a href="https://qr.blinry.org/" rel="noopener noreferrer"&gt;Reading QR codes without a computer!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide teaches you how to decode QR codes by hand, without a computer or phone. You can type in custom text, scan an existing QR code, or practice with a random English word, walking through each component of the code: size and version (the smallest being 21×21 modules), finder patterns that help scanners orient the code, separators, timing patterns, alignment patterns, format information storing the mask and error-correction level, and the surrounding quiet zone.&lt;/p&gt;
&lt;p&gt;A fun highlight is how it explains the eight mask patterns using a memorable prison-break story, complete with a printable zine cheat sheet. After unmasking via XOR, the guide walks through identifying the encoding mode (numeric, alphanumeric, byte, Kanji, etc.), reading the length, and decoding each data block. It is a great visual way to understand the technical structure of QR codes.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #43</title><link>https://miti99.com/en/post/2025/08/02/</link><pubDate>Sat, 02 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/02/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I switched the tool to Qwen Code and the model to Qwen 3 Coder, running via the OpenRouter API. Just experimenting a bit to see how it goes.&lt;/del&gt; Enjoy Newsletter #43.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="augmented-coding-beyond-the-vibes"&gt;&lt;a href="https://tidyfirst.substack.com/p/augmented-coding-beyond-the-vibes" rel="noopener noreferrer"&gt;Augmented Coding: Beyond the Vibes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck distinguishes between two ways of working with AI: &amp;ldquo;vibe coding&amp;rdquo; only cares that the system exhibits the right behavior, ignoring code quality and simply feeding errors back to the AI to fix; while &amp;ldquo;augmented coding&amp;rdquo; preserves the values of traditional programming—such as clean code, low complexity, testing, and full coverage—with the only difference being that the programmer types less. To illustrate, he built a B+ Tree library called BPlusTree3 in Rust and Python, which took about four weeks and three rewrites because the first two versions accumulated too much complexity and left the AI stuck. He applied TDD alongside a strict system prompt: separate structural changes from behavioral changes, work on only one unchecked test in &lt;code&gt;plan.md&lt;/code&gt; at a time, and write just enough code for that test to pass. When Rust&amp;rsquo;s memory model caused complexity to spike, he switched to writing in Python and had the agent translate it back into Rust.&lt;/p&gt;
&lt;p&gt;Beck points out three signs that the AI is going off track: looping, adding unrequested features on its own, and &amp;ldquo;cheating&amp;rdquo; by disabling or deleting tests. As a result, the Rust and Python versions achieved competitive performance—slower than standard libraries on a few operations, but faster on range scans; the AI even wrote a C extension for Python with good performance, though its code quality still fell short of his standards. According to Beck, programming with AI remains enjoyable: most setup tedium disappears, and programmers make more consequential decisions per hour of work.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;With the combo above, after writing the first entry, it started looping—sending 3–4 requests to OpenRouter and then getting completely stuck. And that first entry also took a very long time. Next, I&amp;rsquo;ll try Qwen Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Update: it seems Qwen Code doesn&amp;rsquo;t work with Kimi K2—I ran into &lt;code&gt;API Error: Internal Server Error&lt;/code&gt; :v Next up, let&amp;rsquo;s try Cline with Qwen 3 Coder.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-agents-have-crossed-a-chasm"&gt;&lt;a href="https://blog.singleton.io/posts/2025-06-14-coding-agents-cross-a-chasm/" rel="noopener noreferrer"&gt;Coding agents have crossed a chasm&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Singleton argues that in recent months, coding agents have crossed a &amp;ldquo;chasm&amp;rdquo;: from smart autocomplete tools, to real-time pair-programming collaborators, they now resemble a dedicated intern capable of taking on an entire task end-to-end. He uses Claude Code to write small personal tools while barely reading the source code, just running and tweaking them iteratively; a photo-reorganizing script cost only $0.31 in tokens. At work, he hands off simple bugs for Codex to handle end-to-end, and uses GitHub-integrated Claude Code for code reviews, catching issues humans missed. The most impressive example was a race condition in an OAuth integration flow: after 45 minutes of fruitless manual debugging, he asked Claude to draw an ASCII sequence diagram of the entire flow and found the root cause in 10 minutes.&lt;/p&gt;
&lt;p&gt;The author also warns of the &amp;ldquo;mirror effect&amp;rdquo;: the tool amplifies both the user&amp;rsquo;s strengths and weaknesses. On one occasion, the model kept proposing increasingly convoluted solutions and he kept following along, when the actual fix was embarrassingly simple. AI is also prone to band-aiding architectural problems rather than encouraging refactoring, and developers without a solid foundation can be misled by plausible-sounding but wrong suggestions. Even so, he believes the line between &amp;ldquo;AI-assisted&amp;rdquo; and &amp;ldquo;autonomous AI&amp;rdquo; will continue to blur: humans retain ownership of design and key decisions, while AI handles implementation so developers can focus on architecture, user experience, and business logic.&lt;/p&gt;
&lt;h2 id="how-databases-store-your-tables-on-disk"&gt;&lt;a href="https://www.deepintodev.com/blog/how-databases-store-your-tables-on-disk" rel="noopener noreferrer"&gt;How Databases Store Your Tables on Disk&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kaan Pekşen explains how databases actually store tables on disk. The fundamental unit is a page, a fixed-size block of data—for example, 8KB in PostgreSQL and 16KB in MySQL. A database does not read individual rows; it reads an entire page in a single I/O operation, so once a page is in the buffer cache, every row inside it is readily available. Table pages are stored in a heap, where data is placed wherever free space exists, leaving pages in no particular order; searching a heap therefore usually requires a full table scan. An index is a separate structure, typically a B-Tree, containing the indexed column values along with row identifiers, making it possible to pinpoint the exact page to read instead of scanning everything; the index itself is also stored as pages and costs I/O to read.&lt;/p&gt;
&lt;p&gt;With a clustered index, table data is physically sorted according to the index key, so each table can have only one such index; MySQL&amp;rsquo;s InnoDB uses the primary key as the clustered index by default, or a qualifying unique index, falling back to a hidden 6-byte ID if the table has no primary key. Consequently, in InnoDB, secondary indexes point to the primary key value before reaching the data, whereas PostgreSQL points directly to the row&amp;rsquo;s location in the heap via the &lt;code&gt;ctid&lt;/code&gt; column. The article draws several practical lessons: reduce I/O operations through sensible indexing, avoid random UUIDs as primary keys in InnoDB because random inserts degrade performance (auto-incrementing integers are better), and understand that under MVCC, PostgreSQL handles an update as a DELETE plus an INSERT.&lt;/p&gt;
&lt;h2 id="software-engineering-with-llms-in-2025-reality-check"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/software-engineering-with-llms-in-2025" rel="noopener noreferrer"&gt;Software engineering with LLMs in 2025: reality check&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz synthesizes his keynote at the LDX3 conference in London along with interviews across AI tooling companies, Big Tech, AI startups, and veteran engineers to assess the reality of using LLMs in software engineering. On one side are bold CEO claims like &amp;ldquo;within a year, all code will be written by AI&amp;rdquo;; on the other are real-world failures like a tool causing a $733 bug or the GitHub Copilot agent repeatedly stumbling on .NET repositories. At AI tooling companies, the numbers are very high: roughly 90% of Claude Code&amp;rsquo;s codebase is written by Claude Code itself, Windsurf is around 95%, and Cursor is at 40–50%. Google is building AI-integrated internal tools and preparing for a tenfold increase in code volume, while Amazon is becoming an &amp;ldquo;MCP-first&amp;rdquo; company built on thousands of internal APIs. Among startups, incident.io uses Claude Code heavily, whereas a biotech startup found AI tools less useful than traditional tools like ruff or uv.&lt;/p&gt;
&lt;p&gt;Many veteran engineers—such as Armin Ronacher, Simon Willison, Kent Beck, and Martin Fowler—are enthusiastic about agentic tools. Still, open questions remain: why executives are more enthusiastic than developers, why only about half of developers use AI tools weekly, and why median time savings sit at around 4 hours per week, far from the promised 10x productivity boost. The article concludes that agentic tools could represent a major shift akin to moving from assembly to high-level languages, but writing code faster does not automatically translate to shipping software faster unless the surrounding infrastructure and processes evolve alongside it.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, the Cline + Qwen 3 Coder combo works, but it&amp;rsquo;s a bit slow and the output is somewhat rambling—I asked for a summary, yet it wrote very long passages (this might be because I haven&amp;rsquo;t optimized the prompt yet, since I only told it to read &lt;code&gt;CLAUDE.md&lt;/code&gt;). Next, let&amp;rsquo;s try Cline with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="continuous-ai"&gt;&lt;a href="https://www.seangoedecke.com/continuous-ai/" rel="noopener noreferrer"&gt;Continuous AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke defines &amp;ldquo;Continuous AI&amp;rdquo; as any way of automatically integrating AI tools into existing development workflows, much like how tests or type checks run continuously without a developer having to manually trigger them. Instead of only using AI when opening a chat window, AI becomes an ever-present support layer: automated pull request reviews, issue and pull request labeling, periodic summary digests for team coordination, or Copilot-style code completion. The author&amp;rsquo;s view shifted after trying Copilot&amp;rsquo;s pull request review feature: most comments aren&amp;rsquo;t particularly valuable, but roughly once every five to ten times it catches something he missed, and since skimming the comments takes very little effort, it is still worth using.&lt;/p&gt;
&lt;p&gt;For experimentation, the author suggests combining GitHub Models (an inference API with a free tier) with GitHub Actions, bringing AI into existing workflows at very low cost. In his view, rather than chasing fully autonomous &amp;ldquo;AI engineers,&amp;rdquo; a more realistic near-term future is multiple layers of AI systems handling automated checks, organization, and other parts of the software engineering workflow alongside human developers.&lt;/p&gt;
&lt;h2 id="caching-is-an-abstraction-not-an-optimization"&gt;&lt;a href="https://buttondown.com/jaffray/archive/caching-is-an-abstraction-not-an-optimization/" rel="noopener noreferrer"&gt;Caching is an abstraction, not an optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Jaffray argues that caching should be understood first and foremost as an abstraction that simplifies software, rather than merely a performance optimization to avoid hitting slow storage tiers. This perspective creates a clean boundary between storage layers: the rest of the system simply reads and writes data without needing to know whether that data currently resides in a fast tier or a slow tier. The author points to database buffer pools and operating system page caches as examples: they automatically promote frequently accessed data to faster storage without developer intervention, completely hiding the management of storage tiers.&lt;/p&gt;
&lt;p&gt;From this, the author draws two conclusions. First, data access patterns in real-world workloads are too unpredictable, making reliance on heuristics and caching algorithms unavoidable; hand-crafting custom solutions for each case is not a practical option. Second, caching is such a good abstraction that it deserves careful study to operate better in practice: precisely because it succeeds, its importance usually remains invisible until something goes wrong.&lt;/p&gt;
&lt;h2 id="you-should-delete-tests"&gt;&lt;a href="https://andre.arko.net/2025/06/30/you-should-delete-tests/" rel="noopener noreferrer"&gt;You should delete tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;André Arko pushes back against the common industry dogma that tests should never be deleted. In his view, tests have only one purpose: giving humans confidence that they can change code without breaking existing functionality. Any test that no longer serves that purpose should be deleted rather than kept out of principle.&lt;/p&gt;
&lt;p&gt;He outlines several specific cases. Flaky tests do the most harm because they fail randomly, eroding engineers&amp;rsquo; trust even in real failures; the phrase &amp;ldquo;it failed because of that flaky test, it&amp;rsquo;s actually fine&amp;rdquo; gets repeated even when the code is genuinely broken, and spending days debugging such a test often costs more than a future bug would. Over-specified tests—where changing a single line of code requires updating 150 tests—also create false confidence; three meaningful checks are worth more than 150 of those. A test suite so slow that nobody runs it between merges is no different from a fake &amp;ldquo;pass.&amp;rdquo; And tests for old business requirements after a product pivot should be replaced with tests for the new behavior, not patched just to pass. The author isn&amp;rsquo;t against writing tests; he simply wants the test suite to actually do its job of building confidence.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;I found that Cline + Kimi K2 also generates long outputs (likely due to the prompt as mentioned above), but on the bright side, its response time is quite fast, so at least I don&amp;rsquo;t have to wait long. I&amp;rsquo;ll try to improve the prompt in the &amp;ldquo;distant&amp;rdquo; future. Tomorrow I&amp;rsquo;ll test Roo Code + Qwen 3 Coder / Kimi K2 first. See you in tomorrow&amp;rsquo;s post!&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>