<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Build Systems on miti99</title><link>https://miti99.com/en/tags/build-systems/</link><description>Recent content in Build Systems 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/build-systems/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #67</title><link>https://miti99.com/en/post/2025/12/10/</link><pubDate>Wed, 10 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/10/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post I tried refining my &lt;code&gt;AGENTS.md&lt;/code&gt; file. I&amp;rsquo;ll share my self-assessment at the end of the post.&lt;/del&gt; Enjoy Newsletter #67.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="build-better-software-to-build-software-better"&gt;&lt;a href="https://slack.engineering/build-better-software-to-build-software-better/" rel="noopener noreferrer"&gt;Build better software to build software better&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s engineering team recounts how they cut Quip and Canvas build times from 60 minutes down to 10–30 minutes, built around a central thesis: core software engineering principles apply just as much to build systems as they do to application code. Just like optimizing runtime performance, speeding up builds relies on two levers: caching (doing less work) and parallelism (spreading the load). Bazel supports both out of the box, automatically reusing build outputs when inputs haven&amp;rsquo;t changed and distributing build actions across CPU cores. Even the best build tool, however, cannot save a tangled dependency graph.&lt;/p&gt;
&lt;p&gt;The root problem was that the frontend build depended on the entire compiled backend, so any Python change invalidated the cache and forced a full frontend rebuild, costing an average of 35 minutes each time. The team painstakingly untangled the true inputs of each build step—decoupling backend from frontend, Python infrastructure from TypeScript, and build tooling from application source code—while splitting targets into fine-grained units so individual JS bundles and CSS files could be cached independently. They also fixed a layering violation: frontend bundlers should focus strictly on bundling logic while leaving orchestration and parallelism to Bazel. The result was an up to 6x speedup: 10 minutes in the best case, ~12 minutes on average, and 30 minutes in the worst case.&lt;/p&gt;
&lt;h2 id="things-i-don"&gt;&lt;del&gt;&lt;a href="https://medv.io/blog/things-i-dont-like-in-configuration-languages/" rel="noopener noreferrer"&gt;Things I Don&amp;rsquo;t Like in Configuration Languages&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Anton Medvedev analyzes the pain points of various configuration languages and explains why he decided to create his own language, MAML (Minimal And Markup Language). The article offers an insightful look into the pros and cons of configuration formats ranging from YAML and JSON to newer alternatives.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- YAML has an overly complex specification with too many unnecessary features&lt;/del&gt;
&lt;del&gt;- JSON has won as a universal data-interchange format, but has a few small rough edges worth improving&lt;/del&gt;
&lt;del&gt;- TOML lacks a null value and has confusing array-of-tables syntax&lt;/del&gt;
&lt;del&gt;- Languages like Pkl, CUE, and Dhall are full programming languages rather than simple markup languages&lt;/del&gt;
&lt;del&gt;- The author created MAML based on JSON with a strict specification and a distinctive name&lt;/del&gt;
&lt;del&gt;- MAML keeps JSON&amp;rsquo;s readability while adding comments and multiline strings&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="here"&gt;&lt;a href="https://seconds0.substack.com/p/heres-whats-next-in-agentic-coding/" rel="noopener noreferrer"&gt;Here&amp;rsquo;s What&amp;rsquo;s Next in Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post predicts the next wave of developments in agentic coding, centered on a single thesis: context management is king. A great agent harness must feed the model the exact information it needs while keeping noise out of the context window. According to the author, Plan Mode will become far more sophisticated, flipping the effort ratio between planning and execution from 20:80 to 80:20 so an agent can one-shot an entire feature in a single run. Codebase search will blend &lt;code&gt;grep&lt;/code&gt; with semantic embeddings, external reference docs (such as via Context7 MCP) will be fetched just in time, and rules and skills will load conditionally so they don&amp;rsquo;t pollute context.&lt;/p&gt;
&lt;p&gt;At the multi-agent orchestration layer, the author expects techniques like Best-of-N sampling, pairing an expensive frontier model for planning with a cheaper model for execution, and delegating to subagents for parallel, context-isolated tasks coordinated by a lead agent that shields the user from micromanagement. Output quality will climb through self-critique and evaluation loops, harnesses that proactively suggest improvements to their own configuration, and persistent memory systems that retain knowledge about the user and codebase across sessions. As the author notes, the current pace of iteration in this space is unprecedented.&lt;/p&gt;
&lt;h2 id="why-agents-do-not-write-most-of-our-code---a-reality-check"&gt;&lt;del&gt;&lt;a href="https://octomind.dev/blog/why-agents-do-not-write-most-of-our-code-a-reality-check/" rel="noopener noreferrer"&gt;Why agents DO NOT write most of our code - a reality check&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Even though Octomind builds AI agents for a living, their team reports that most of their own production code is still written by humans. After months of using Cursor, Claude Code, and Windsurf, no one on the team saw a transformative productivity boost (20% or more). To test the limits, two engineers spent a week trying to build a real feature—branch-specific copies of test cases—entirely with AI. On the first attempt, despite detailed specs and an updated rules file, the agent stumbled on basics: forgetting to regenerate the Prisma client after schema changes, creating UI components without wiring them up, writing inefficient queries, and confidently declaring the job done. The result was a 2,000-line PR that needed fixes on nearly every screen. A second attempt with smaller, incremental tasks still produced a 1,200-line PR for just a fraction of the feature, complete with broken database transaction handling.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, the most dangerous failure mode is developers losing their mental model of the codebase as AI dumps thousands of lines of changes in at a time, making every tough debugging session feel like your first day at a new job. The second issue is that AI doesn&amp;rsquo;t know its own limits and always acts confident, whereas a human intern knows how to say &amp;ldquo;I&amp;rsquo;ve never done this before.&amp;rdquo; Still, AI remains genuinely useful for brainstorming, debugging, autocomplete, writing unit tests, and small localized refactors, and narrowly scoped specialist agents continue to deliver real value.&lt;/p&gt;
&lt;h2 id="clarifying-the-rule-of-three-in-refactoring"&gt;&lt;a href="https://blog.jbrains.ca/permalink/clarifying-the-rule-of-three-in-refactoring/" rel="noopener noreferrer"&gt;Clarifying the Rule of Three in Refactoring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;J.B. Rainsberger clarifies the &amp;ldquo;Rule of Three&amp;rdquo; in refactoring—the heuristic that you should wait until duplication appears three times before extracting a shared abstraction—which often sparks debate. In Rainsberger&amp;rsquo;s view, the rule is primarily aimed at Advanced Beginners to keep them from mechanically deduplicating everything on sight. He distinguishes between two contexts: when you are practicing design through refactoring, aggressively removing duplication and occasionally regretting it is how you sharpen your design judgment; when you are focused on shipping under a deadline, waiting helps avoid rework in case future changes force you to reintroduce the duplication. The Rule of Three is therefore a teaching aid for balancing learning and delivery, not an ironclad law.&lt;/p&gt;
&lt;p&gt;Personally, Rainsberger prefers removing duplication early because he is comfortable inlining code back again as soon as an extraction turns out to be wrong, viewing that reversal as a natural part of learning. Removing duplication early also helps surface useful abstractions hiding in the design. His advice to developers is to get comfortable undoing a refactoring, and if you invoke the Rule of Three, make sure it rests on clear reasoning rather than vague fear.&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_!9vpY!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff5f41f86-4bf2-4b21-85aa-69659c039111_2250x2624.png" alt="Top Strategies to Share Data Between Services"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!aRQC!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa760cf81-6245-4051-be41-f867616e0faf_2250x2862.png" alt="Scalability Patterns for Modern Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=6u25GckPhLU" rel="noopener noreferrer"&gt;Design a Web Crawler: FAANG Interview Question&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;URL processing worked reasonably well—it used less untranslated English this time, though a bit of&amp;hellip; Chinese slipped in :| The bonus section was pretty rough, mainly because when you only pass raw image URLs to the AI, it struggles to find the right title and sometimes hallucinates completely unrelated labels.&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #65</title><link>https://miti99.com/en/post/2025/12/08/</link><pubDate>Mon, 08 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/08/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Lately the free models on OpenRouter have been pretty unstable—sometimes they work, sometimes they don&amp;rsquo;t. Since I still had a few dollars of credit left there, I decided to burn through the rest today before switching over to iFlow full-time (until iFlow stops being free :v).&lt;/del&gt; Enjoy Newsletter #65. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://openrouter.ai" rel="noopener noreferrer"&gt;OpenRouter&lt;/a&gt; &amp;amp; &lt;a href="https://openrouter.ai/anthropic/claude-sonnet-4.5" rel="noopener noreferrer"&gt;Anthropic: Claude Sonnet 4.5&lt;/a&gt; (a &amp;lsquo;premium&amp;rsquo; model hehe)&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="scaling-engineering-teams-lessons-from-google-facebook-and-netflix"&gt;&lt;a href="https://greenido.dev/2025/09/25/scaling-engineering-teams-lessons-from-google-facebook-and-netflix/" rel="noopener noreferrer"&gt;Scaling Engineering Teams: Lessons from Google, Facebook, and Netflix&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ido Green, drawing on more than a decade of engineering leadership at Google, Facebook, and Netflix, argues that when scaling from 10 to over 1,000 engineers, whether an organization thrives or collapses comes down to three pillars: structured goal-setting, an uncompromising focus on code quality, and intentional culture-building. At Google, OKRs are set ambitiously—3–5 objectives per team with 2–4 measurable key results each—where hitting 60–70% is the sweet spot and 100% means the goals weren&amp;rsquo;t ambitious enough. For code quality, Facebook requires every line of code to be reviewed, every part of the codebase to have an owner, and new code to maintain at least 80% test coverage; Netflix proactively injects failures with Chaos Monkey (randomly terminating production instances), runs failure drills, and rolls out canaries to 1% of users first.&lt;/p&gt;
&lt;p&gt;On culture, Google sets aside one afternoon a month for experimentation; Facebook puts new hires through a 6-week Bootcamp where they fix bugs across the stack before choosing a team; and Netflix hires top talent, pays top-of-market compensation, and treats people like adults. Green recommends tracking the four DORA metrics such as deployment frequency and mean time to recovery. The biggest lesson: hero culture, manual processes, and tribal knowledge work at 10 people but become a disaster at 100; what scales are systems, documentation, automation, and clear ownership. Rather than cargo-culting practices, execute consistently and measure what matters.&lt;/p&gt;
&lt;h2 id="the-trap-of-excessive-ai-use"&gt;&lt;a href="https://dpereira.substack.com/p/the-trap-of-excessive-ai-use" rel="noopener noreferrer"&gt;The Trap of Excessive AI Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Pereira, author of &lt;em&gt;Untrapping Product Teams&lt;/em&gt;, warns that overusing AI makes us mediocre rather than better. He isn&amp;rsquo;t anti-AI, but opposes the &amp;ldquo;automate everything&amp;rdquo; mindset—the assumption that if AI can do something, we no longer need to care about it. AI makes us faster, not wiser. He points to troubling habits: delegating prioritization to AI, having AI write PRDs instead of thinking through what actually matters, summarizing everything instead of learning deeply, and replacing real user research with AI-generated insights. Critical thinking, understanding human behavior, and challenging assumptions must remain ours; paradoxically, the more people rush to outsource everything to AI, the more valuable those who don&amp;rsquo;t become.&lt;/p&gt;
&lt;p&gt;Pereira shares his own &amp;ldquo;old-school&amp;rdquo; habits—reading every message himself, writing his own emails to give himself time to think, reading whole books cover to cover, taking handwritten notes, and single-tasking—viewing them as a competitive edge. Still, AI is great for accelerating low-value work (drafting meeting notes, summarizing competitor features), exploring alternatives and stress-testing assumptions, tailoring messaging for different audiences, and brainstorming experiment ideas to learn faster. His rule of thumb is &amp;ldquo;AI can draft, but I decide&amp;rdquo;: delegate tasks, never ownership, because letting AI decide crosses the line from leveraging a tool to abdicating responsibility.&lt;/p&gt;
&lt;h2 id="how-google-amazon-and-crowdstrike-broke-millions-of-systems"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/how-google-amazon-and-crowdstrike" rel="noopener noreferrer"&gt;How Google, Amazon, and CrowdStrike Broke Millions of Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Milan Milanović dissects three massive outages showing how even simple bugs can turn catastrophic at hyperscale. In October 2025, a race condition in DynamoDB&amp;rsquo;s automated DNS management in &lt;code&gt;us-east-1&lt;/code&gt; caused a 15-hour AWS outage across 113 services: a delayed DNS Enactor overwrote Route 53 with a stale plan right as another Enactor cleaned up &amp;ldquo;expired&amp;rdquo; plans, wiping out the DNS records entirely—a classic time-of-check to time-of-use (TOCTOU) bug. DNS was restored after about 3 hours, but cascading failures dragged on for another 12. In June 2025, Google Cloud went down for roughly 7 hours: new code in Service Control, the gateway for every API call, lacked a null check and wasn&amp;rsquo;t gated behind a feature flag; it lay dormant for 14 days until a policy with a blank field was replicated globally via Spanner in seconds.&lt;/p&gt;
&lt;p&gt;The third outage struck in July 2024: Channel File 291 triggered an out-of-bounds array read inside CrowdStrike&amp;rsquo;s kernel-mode interpreter, sending 8.5 million Windows machines into boot loops that had to be fixed manually in Safe Mode one machine at a time. Across all three incidents, speed was prioritized over safety, single points of failure had massive blast radii, and automated recovery mechanisms themselves became failure amplifiers. The takeaways: use atomic state transitions, add circuit breakers and jittered backoff to recovery loops, roll out changes in stages with canaries, validate data before global replication, and test configuration with the same rigor as code.&lt;/p&gt;
&lt;h2 id="the-linux-boot-process-from-power-button-to-kernel"&gt;&lt;a href="https://www.0xkato.xyz/linux-boot/" rel="noopener noreferrer"&gt;The Linux Boot Process: From Power Button to Kernel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post walks clearly through how Linux boots on x86 hardware, from pressing the power button to the kernel&amp;rsquo;s entry point, focusing primarily on the traditional BIOS flow (UEFI or alternative bootloaders skip some of these steps). When power comes on, the CPU resets into 16-bit real mode—a legacy of the original 8086—and jumps to the reset vector at &lt;code&gt;0xFFFFFFF0&lt;/code&gt;, where firmware places a jump instruction into its own initialization code. Legacy BIOS scans disks for a 512-byte boot sector ending in &lt;code&gt;0x55&lt;/code&gt; &lt;code&gt;0xAA&lt;/code&gt;, whereas modern UEFI understands filesystems and loads larger boot binaries directly. A bootloader like GRUB loads the kernel image into memory, populates the setup header, and hands control to the kernel&amp;rsquo;s setup code. That code establishes a predictable environment: normalizing segment registers, setting up a stack, zeroing the BSS section, and querying firmware for the system memory map via the &lt;code&gt;e820&lt;/code&gt; BIOS interrupt. Next come two mode transitions: into 32-bit protected mode (disabling interrupts, enabling the A20 line, loading minimal GDT and IDT tables, and setting the PE bit in &lt;code&gt;CR0&lt;/code&gt;), and then into 64-bit long mode (enabling PAE in &lt;code&gt;CR4&lt;/code&gt;, building identity-mapped page tables, loading their address into &lt;code&gt;CR3&lt;/code&gt;, and setting the LME bit in &lt;code&gt;EFER&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;Once in 64-bit mode, &lt;code&gt;extract_kernel&lt;/code&gt; decompresses the kernel image (&lt;code&gt;gzip&lt;/code&gt;, &lt;code&gt;xz&lt;/code&gt;, &lt;code&gt;zstd&lt;/code&gt;, etc.), parses the ELF header to place code and data sections, applies relocations if the kernel isn&amp;rsquo;t loaded at its default address, and jumps into &lt;code&gt;start_kernel&lt;/code&gt;. The article also explains kASLR: the decompressor picks random physical and virtual base addresses within available memory ranges—carefully avoiding occupied regions like &lt;code&gt;initrd&lt;/code&gt;—making it much harder for attackers to guess where kernel code lives, and falling back to the default address if no suitable slot is found. Complete with a glossary, it&amp;rsquo;s an approachable primer for newcomers.&lt;/p&gt;
&lt;h2 id="build-system-tradeoffs"&gt;&lt;a href="https://jyn.dev/build-system-tradeoffs" rel="noopener noreferrer"&gt;Build System Tradeoffs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;jyn, who works on the build system for the Rust compiler, kicks off a series on build systems with a survey of what complex builds actually have to juggle: running binaries that were just built as part of the build itself (like integration tests invoking &lt;code&gt;cargo build&lt;/code&gt; inside &lt;code&gt;cargo test&lt;/code&gt;), accurate dependency tracking, cross-compilation (requiring compilers, standard libraries, and linkers for both host and target platforms), choosing between dynamic and static linking, and reproducible builds—a prerequisite for safe caching. According to the author, the most common mistake is forcing build configuration into a restrictive custom DSL: purely &amp;ldquo;declarative&amp;rdquo; builds are an illusion, so it&amp;rsquo;s far better to express build logic in a real programming language and serialize the resulting build graph into a minimal format like Ninja.&lt;/p&gt;
&lt;p&gt;For dependency tracking, there are four main approaches. Manual declarations—even with compiler assistance like &lt;code&gt;gcc -M&lt;/code&gt;—are error-prone. Always rebuilding from scratch is guaranteed correct but slow. Hermetic builds like Bazel, Buck2, and Nix restrict steps to explicitly declared inputs, unlocking safe remote caching. Tracing builds like Tup and Ekam discover dependencies automatically by intercepting syscalls, requiring zero manual declarations, but mostly only work on Linux and struggle to scale because the graph isn&amp;rsquo;t known upfront. The author concludes that prioritizing correctness always comes with trade-offs, combining syscall tracing with hermetic sandboxing looks like the sweet spot, and writing build rules in a general-purpose language that compiles down to a serialized graph has surprisingly few downsides.&lt;/p&gt;
&lt;h2 id="how-i-use-every-claude-code-feature"&gt;&lt;a href="https://blog.sshh.io/p/how-i-use-every-claude-code-feature" rel="noopener noreferrer"&gt;How I Use Every Claude Code Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar shares how he uses nearly every feature of Claude Code in practice. The most important foundation is the root &lt;code&gt;CLAUDE.md&lt;/code&gt; file—the agent&amp;rsquo;s &amp;ldquo;constitution&amp;rdquo;: at his company, it is capped at 13KB and documents only tools used by at least 30% of engineers. He advises starting with guardrails based on mistakes Claude actually makes rather than writing an exhaustive manual, avoiding &lt;code&gt;@&lt;/code&gt;-mention file embeds because they bloat context, and never writing a negative rule without providing the preferred alternative. Within the 200k-token context window, he avoids &lt;code&gt;/compact&lt;/code&gt; because it&amp;rsquo;s opaque and lossy, preferring &lt;code&gt;/clear&lt;/code&gt; paired with a custom &lt;code&gt;/catchup&lt;/code&gt; command that re-reads changed files, or having Claude dump progress to a &lt;code&gt;.md&lt;/code&gt; file before starting a fresh session. He avoids custom subagents because they hide context and force the agent into rigid human workflows; instead, the main agent uses &lt;code&gt;Task(...)&lt;/code&gt; to spawn clones of itself—a pattern he calls &amp;ldquo;Master-Clone.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Hooks are invaluable in enterprise repos: blocking commits when tests haven&amp;rsquo;t passed, paired with non-blocking suggestion hooks, while avoiding block-at-write hooks that confuse the agent mid-task. Echoing Simon Willison, he argues Skills may matter more than MCP because they formalize the &amp;ldquo;scripting&amp;rdquo; paradigm—the evolutionary step after single prompts and tool calling—leaving MCP as a narrow security gateway for stateful environments like Playwright. Finally, the most underrated feature is the Claude Code GitHub Action: full container control, tight sandboxing, and complete audit logs that can be mined periodically to improve &lt;code&gt;CLAUDE.md&lt;/code&gt; and developer tooling.&lt;/p&gt;
&lt;h2 id="if-you-don"&gt;&lt;a href="https://seated.ro/blog/tinkering-a-lost-art" rel="noopener noreferrer"&gt;If you don&amp;rsquo;t tinker, you don&amp;rsquo;t have taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;seatedro writes about &amp;ldquo;tinkering&amp;rdquo;—poking at small things and tweaking them just to see how they can be improved—as a lifelong learning tool. The author tried everything from guitar and art to martial arts, yet didn&amp;rsquo;t start tinkering with programming until relatively late; once it clicked, it became central to how they learn, and they wish they had started sooner. Tinkering means spending hours dialing in mouse sensitivity in a game, losing days configuring a Linux window manager just for fun, or taking apart a mechanical keyboard to swap keycaps and test switches. Some people only do things that serve a concrete goal, while others do things &amp;ldquo;just because&amp;rdquo;; the ideal is combining both. The author quotes &lt;code&gt;@ludwigABAP&lt;/code&gt; that tinkering and throwing the result away is practice, and practice should be ephemeral, exploratory, and frequent.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, using Git from the command line instead of GitHub Desktop or knowing basic Vim motions should be baseline literacy rather than a rarity, though balance still matters: the last time they tweaked their Neovim config was six months ago. In a single week, the author wrote their first GLSL fragment shader, Rust procedural macro, C++ template, and Swift app, and tried out the Helix editor—none of it strictly necessary. The core message is that &amp;ldquo;taste&amp;rdquo;—the ability to tell mediocrity from excellence—only develops when you try lots of things, keep what resonates, and discard what doesn&amp;rsquo;t; so question defaults, experiment, and break things every day.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!Fxka!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F60f07f90-6f22-4b1f-ab2e-d98e8ccc755a_3000x3900.png" alt="10 Key Data Structures We Use Every Day"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Nizo!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fffa24eaf-4fc7-4278-a0df-faddb41c765f_2048x2662.png" alt="IP Address Cheat Sheet Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ZdF6!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fef416976-ae0f-48f5-86e1-0189c0b9be88_2360x2664.png" alt="Which Protocols Run on TCP and UDP"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;Whoa, it hit the credit limit right while processing the last URL. I started with $2 (around 52k VND) and it only processed 7 URLs, which comes out to ~7.5k VND per article. Pretty steep :v And the output still wasn&amp;rsquo;t quite what I wanted, since it still overused English terms—you can clearly see that in the last summary. It might be an issue with my &lt;code&gt;AGENTS.md&lt;/code&gt; file, so I&amp;rsquo;ll optimize that later. Either way, I achieved my goal of burning through the remaining credit so I can go back to using free tiers :v See you in upcoming posts :D.&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>