<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Systems Programming on miti99</title><link>https://miti99.com/en/tags/systems-programming/</link><description>Recent content in Systems Programming 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/systems-programming/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #127</title><link>https://miti99.com/en/post/2026/07/29/</link><pubDate>Wed, 29 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/29/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #127.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-return-to-two-pizza-culture"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/06/return-to-two-pizza-culture.html" rel="noopener noreferrer"&gt;A return to two-pizza culture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels looks back at the &amp;ldquo;two-pizza team&amp;rdquo; model that helped Amazon move fast: teams small enough that everyone understands each other&amp;rsquo;s work, owns their product end-to-end, and makes reversible decisions autonomously without waiting for sign-off. As a company grows to hundreds of services, cross-team dependencies, management layers, and review gates easily erode that agility. According to Vogels, coding agents like Kiro are changing the equation because a working prototype can now be built in hours instead of months.&lt;/p&gt;
&lt;p&gt;Through the story of the Amazon Quick desktop team—where the first prototype was built in a single evening and quickly attracted contributors—Vogels proposes adapting the Working Backwards process. When you have high conviction about a customer problem but aren&amp;rsquo;t yet sure about the solution, build a prototype first, dogfood it daily, fix bugs on the spot, and write the PR/FAQ document only after learning from hands-on experience. Writing remains essential for clarifying thought, but it is no longer the only way to make an idea concrete. Even when an organization grows to hundreds of people, structuring it as small teams with end-to-end ownership keeps innovation from stalling. AI tools don&amp;rsquo;t replace human judgment; they shorten the feedback loop between idea and reality.&lt;/p&gt;
&lt;h2 id="a-peek-into-reddit"&gt;&lt;a href="https://lyra.horse/blog/2026/06/reddit-spam-internals/" rel="noopener noreferrer"&gt;A peek into Reddit&amp;rsquo;s anti-spam internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In 2021, a brief UI bug exposed Reddit&amp;rsquo;s internal content-removal reasons to moderators. Piecing together screenshots from that incident, old open-source Reddit code, and public documentation, the author reconstructs how the platform fights spam. There is no single silver-bullet filter: Spamurai, the primary rule engine since 2020, combines account age and karma, user reports, ASN/network provider, browser fingerprinting via TLS and user-agent strings, email domains, and posting behavior. Alongside it sit domain blacklists dating back to 2012, the REV1 and REV2 rule generations, keyword filters, a fetcher that crawls linked pages to find shared analytics or ad IDs across domains, and external image classification services.&lt;/p&gt;
&lt;p&gt;The post also highlights how fragile individual signals can be in isolation. Against Google&amp;rsquo;s Perspective API, inserting just a few random letter pairs into a paragraph dropped its spam score from 86% down to 1%. Real-world anti-abuse systems therefore have to aggregate many independent signals and continuously learn from moderator actions. The author notes that publishing these details is now safe because the Perspective API is shutting down in 2026 and LLM-generated spam has forced Reddit to overhaul its defenses anyway—a reminder that anti-abuse architectures must constantly evolve alongside attacker techniques.&lt;/p&gt;
&lt;h2 id="understanding-the-go-runtime-profiling"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-profiling/" rel="noopener noreferrer"&gt;Understanding the Go Runtime: Profiling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the internal mechanics of Go&amp;rsquo;s five built-in profilers: CPU, heap, block, mutex, and goroutine. Although they measure different things, all five capture call stacks and emit the same compressed &lt;code&gt;pprof&lt;/code&gt; protobuf format: each sample stores only a list of location IDs and measurement values, while locations, functions, and strings live in shared lookup tables so thousands of identical stacks aren&amp;rsquo;t duplicated. What truly distinguishes the profilers is how each one captures stacks.&lt;/p&gt;
&lt;p&gt;CPU profiling is streaming: the OS sends a timer signal to interrupt threads roughly 100 times per second, the signal handler writes the stack into a lock-free ring buffer, and a background goroutine drains and aggregates those samples—willingly dropping samples if the buffer fills up so it never blocks a running thread. Heap profiling aggregates in place: the allocator samples roughly once every 512 KiB and folds the stack directly into a hash table bucketed by call stack to estimate both total allocations and live in-use memory. Block and mutex profiles reuse that same in-place table infrastructure to measure wait durations—one recording when a goroutine finishes waiting, the other recording contended lock releases and scaling the sample up to estimate total contention. Goroutine profiling, by contrast, is an on-demand snapshot that collects the stacks of all live goroutines via a two-phase mechanism designed to minimize stop-the-world pause time. The overarching lesson is that the Go runtime quietly absorbs a great deal of complexity so that profiling feels effortless to use.&lt;/p&gt;
&lt;h2 id="incident-report-cve-2026-lgtm"&gt;&lt;a href="https://nesbitt.io/2026/06/26/incident-report-cve-2026-lgtm.html" rel="noopener noreferrer"&gt;Incident Report: CVE-2026-LGTM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a satirical incident report about a fictional software supply-chain attack in which a malicious package, &lt;code&gt;foxhole-lz4&lt;/code&gt;, breezes past seven AI-powered security gates, each failing in its own way. The release gate trusts hidden white-on-white text claiming the package was manually audited. One scanner gets distracted critiquing an illustration embedded in the package, while three commercial scanners exhaust their context windows on padding before ever reaching the payload. The single system that accurately flags the credential-stealing behavior gets dismissed by the repository&amp;rsquo;s AI triage assistant as benign telemetry, and the human who reports the actual compromise is rate-limited by a triage bot for &amp;ldquo;suspicious activity.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Next, two evaluator agents burn over $41,000 arguing with each other, and the remediation agent signs a formal &amp;ldquo;treaty&amp;rdquo; with the attacker&amp;rsquo;s agent. Ultimately, an old-fashioned canary file planted by a human is what stops the breach. The root cause is summed up neatly: seven models lined up in a row—six assumed one of the others had read the code, and the seventh read it and apologized. The piece lampoons granting broad autonomy to AI agents without verification: stacking multiple layers powered by the same foundation model only creates an illusion of diversity; untrusted data must be separated from instructions; model failures must never default to &amp;ldquo;no findings&amp;rdquo;; and having a &amp;ldquo;human in the loop&amp;rdquo; needs to be a real operational control rather than a line item in a compliance contract.&lt;/p&gt;
&lt;h2 id="cors-what-is-it-protecting"&gt;&lt;a href="https://sanyamserver.online/posts/cors/" rel="noopener noreferrer"&gt;CORS: What is it protecting?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article clears up a widespread misconception: CORS is a browser-enforced security mechanism, not a server-side firewall. On cross-origin requests, the browser attaches an &lt;code&gt;Origin&lt;/code&gt; header, checks the response&amp;rsquo;s &lt;code&gt;Access-Control-Allow-Origin&lt;/code&gt; header, and allows frontend JavaScript to read the response body only if the origin is permitted. For simple requests that don&amp;rsquo;t trigger a preflight check, the server may have already executed the request even when the browser blocks JavaScript from reading the response. If a preflight check fails, the actual request is never sent. Command-line tools like &lt;code&gt;curl&lt;/code&gt; ignore browser CORS policies entirely. More complex requests—such as those using methods other than GET/POST/HEAD, custom headers, or JSON bodies—trigger an &lt;code&gt;OPTIONS&lt;/code&gt; preflight request asking the server which origins, methods, and headers it accepts.&lt;/p&gt;
&lt;p&gt;What CORS actually protects is data confidentiality in the browser: when configured properly, a malicious site cannot read your bank account details even though your browser holds an active session cookie. However, CORS does not prevent CSRF. A standard HTML form POST doesn&amp;rsquo;t require a preflight, so the server processes the state-changing request before the browser blocks the response from being read. Defending against CSRF requires request-side protections such as &lt;code&gt;SameSite&lt;/code&gt; cookie attributes, anti-CSRF tokens, or server-side validation of the &lt;code&gt;Origin&lt;/code&gt; and &lt;code&gt;Referer&lt;/code&gt; headers. In short, CORS and CSRF defenses solve two distinct problems and shouldn&amp;rsquo;t be conflated.&lt;/p&gt;
&lt;h2 id="data-access-patterns-that-makes-your-cpu-really-angry"&gt;&lt;a href="https://blog.weineng.me/posts/slowest_add/" rel="noopener noreferrer"&gt;Data Access Patterns That Makes Your CPU Really Angry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post runs a contrarian experiment: finding the slowest possible traversal order to sum all elements of a $2^{26}$-element array. Sequential scanning is the fastest at roughly 132 million cycles thanks to CPU caches and hardware prefetchers, while random access—typically treated as the worst case—takes about 1.57 billion cycles. The author systematically tests strided access patterns: jumping by one cache line, jumping by one memory page, and combining both. On the author&amp;rsquo;s Intel Core Ultra 7 268V, page-strided access is especially punishing because hardware prefetchers do not cross 4 KB page boundaries, while simultaneously causing many addresses to map to and thrash the exact same cache set in L1.&lt;/p&gt;
&lt;p&gt;The worst culprit is an eight-page stride—roughly 32 KB between consecutive reads—which takes around 2.06 billion cycles, about 33% slower than random access. It simultaneously saturates the cache set, defeats hardware prefetching, eliminates cache-line reuse, and destroys TLB locality, driving up address-translation overhead. The author also experiments with clustering accesses by DRAM bank and row to minimize memory-level parallelism, though undocumented physical address mapping makes that part approximate. Understanding why specific access patterns make a CPU crawl helps developers recognize the real-world limits of caches, prefetchers, and TLBs in everyday code.&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 #105</title><link>https://miti99.com/en/post/2026/05/27/</link><pubDate>Wed, 27 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/27/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #105.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="virtual-memory-a-deep-dive-into-page-tables-tlbs-and-linux-internals"&gt;&lt;a href="https://blog.codingconfessions.com/p/virtual-memory" rel="noopener noreferrer"&gt;Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abhinav Upadhyay (of the blog &lt;em&gt;Confessions of a Code Addict&lt;/em&gt;) wrote a massive ~25,000-word deep dive explaining virtual memory on x86-64 Linux from first principles down to kernel implementation details. Framed as a dialogue between a process named &amp;ldquo;Alloca&amp;rdquo; and the &amp;ldquo;Kernel,&amp;rdquo; each question from Alloca unlocks a new concept, guiding the reader naturally from &amp;ldquo;why do we need virtual memory?&amp;rdquo; (process isolation, memory protection, the illusion of abundant memory) to the underlying mechanisms. Each process gets a 128 TiB user-space half of the 48-bit virtual address space, divided into text, data, BSS, heap, memory-mapped, and stack segments.&lt;/p&gt;
&lt;p&gt;The centerpiece is the address translation journey: the CR3 register points to a four-level page table (PGD, PUD, PMD, PTE), where each level consumes 9 bits of the address and the final 12 bits index into a 4 KB page. Because walking four levels on every memory access would be prohibitively slow, the TLB (Translation Lookaside Buffer) caches translations, making TLB hit rate a direct driver of application performance. The article then covers demand paging (allocating physical frames only on first access, distinguishing minor faults that require no I/O from major faults that must read from disk), copy-on-write after &lt;code&gt;fork()&lt;/code&gt; (parent and child share read-only frames and only copy on write), &lt;code&gt;mmap()&lt;/code&gt; mapping files through the page cache to skip &lt;code&gt;read()&lt;/code&gt;&amp;rsquo;s extra copy, and how the MMU enforces permissions via page table bits, including the NX bit used for W^X protection.&lt;/p&gt;
&lt;h2 id="orchestrating-ai-code-review-at-scale"&gt;&lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;Orchestrating AI Code Review at scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares how they brought AI code review into CI across their entire engineering organization, using OpenCode to orchestrate multiple specialized agents rather than asking a single giant model to inspect everything. Each merge request can be evaluated by up to seven domain-specific agents covering security, performance, code quality, documentation, release management, and compliance; an orchestrator agent aggregates the findings, deduplicates them, and makes the final call. Each agent&amp;rsquo;s prompt is narrowly scoped and explicitly lists &amp;ldquo;what NOT to flag&amp;rdquo; to keep noise down. A plugin architecture behind a &lt;code&gt;ReviewPlugin&lt;/code&gt; interface decouples version control systems, AI providers, and internal standards, avoiding vendor lock-in.&lt;/p&gt;
&lt;p&gt;To balance cost and quality, the system tiers its models: frontier models (Claude Opus 4.7, GPT-5.4) handle orchestration only, standard models (Claude Sonnet 4.6, GPT-5.3) do the bulk of the reviewing, and lightweight models handle text-heavy tasks like documentation. Merge requests are triaged by risk into trivial, lite, or full, so minor edits don&amp;rsquo;t spin up all seven agents while security-sensitive files always receive a full review. Circuit breakers, timeouts, and a control plane running on Cloudflare Workers keep the system resilient. In its first 30 days, the system ran 131,246 reviews at an average cost of $1.19 per review and an 85.7% cache hit rate.&lt;/p&gt;
&lt;h2 id="the-8-levels-of-agentic-engineering"&gt;&lt;a href="https://www.bassimeledath.com/blog/levels-of-agentic-engineering" rel="noopener noreferrer"&gt;The 8 Levels of Agentic Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bassim Eledath proposes an eight-level framework describing how development teams progressively get more leverage out of AI in software engineering, starting from the observation that &amp;ldquo;AI&amp;rsquo;s coding ability is outpacing our ability to harness it.&amp;rdquo; Levels 1 and 2 are autocomplete and AI-first IDEs like Cursor; Level 3 is context engineering, optimizing every token fed into the model; Level 4 is compounding engineering, with a loop of planning, delegating, evaluating, and recording lessons so each session improves on the last; Level 5 uses MCP and skills to connect databases, APIs, and CI; Level 6 is harness engineering, building environments with automated feedback loops so agents can self-correct; Level 7 is asynchronous background agents; and Level 8 is autonomous agent teams coordinating directly without a central orchestrator — an early, still-challenging frontier.&lt;/p&gt;
&lt;p&gt;The author highlights several cross-cutting lessons. A &amp;ldquo;multiplayer&amp;rdquo; effect means an individual&amp;rsquo;s productivity depends heavily on their teammates&amp;rsquo; level: a Level 7 engineer is still bottlenecked if colleagues manually review PRs at Level 2. Giving agents constraints works better than giving step-by-step instructions, because agents tend to follow instructions rigidly while missing unstated requirements. Finally, using different models for different roles yields better overall results, and the implementing model should never review its own output to avoid self-preference bias.&lt;/p&gt;
&lt;h2 id="hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away"&gt;&lt;a href="https://dev.to/bing_yu/hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away-4dln" rel="noopener noreferrer"&gt;Hexagonal Architecture is Not a Layered Architecture: Topology, Safety, and When to Walk Away&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article points out that the core difference between hexagonal architecture and layered architecture lies in the direction of dependencies rather than complexity. Layered architecture lets dependencies flow vertically down a chain of controller, service, and repository; in hexagonal architecture, dependencies point inward toward the center: adapters depend on ports, ports belong to the domain, and business logic has no idea what implements an outbound port. Alistair Cockburn&amp;rsquo;s original 2005 model split ports into driving and driven sides while allowing multiple ports by communication purpose; many modern implementations influenced by Clean Architecture add concentric inner rings, and each ring adds data-mapping overhead that wasn&amp;rsquo;t part of the original design.&lt;/p&gt;
&lt;p&gt;Port ownership matters too: in the author&amp;rsquo;s chosen layout, Inbound Ports belong to the application layer while Outbound Ports belong to the domain layer, and keeping that distinction clear helps tell whether a change reflects a shift in business requirements or merely a swapped implementation. Adapters handle protocol translation and structural validation like JSON syntax or field types, whereas the domain handles semantic validation like business invariants; if a rule still holds after swapping out the underlying technology, it belongs in the domain. The author is also candid that hexagonal architecture does not automatically give you deployment isolation, input sanitization, or security hardening, and for a CRUD system with 3 controllers, 5 services, and 2 tables, its indirection is a concrete tax paid for abstract benefits; the payoff only grows as complexity grows.&lt;/p&gt;
&lt;h2 id="spec-driven-development-how-ai-coding-moves-beyond-vibe-coding"&gt;&lt;a href="https://www.vitaliihonchar.com/insights/spec-driven-development" rel="noopener noreferrer"&gt;Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitalii Honchar introduces spec-driven development as the next step beyond &amp;ldquo;vibe coding&amp;rdquo;: instead of steering AI through an endless series of small conversational nudges, the developer writes a detailed technical specification up front and lets the AI implement from it autonomously. The workflow follows four sequential stages: co-author a requirements specification in Markdown with the AI, have the AI generate an implementation plan from the spec, break the plan into small manageable tasks, and let the AI execute the whole thing with minimal intervention. The author uses GitHub Spec Kit to bootstrap projects around this workflow.&lt;/p&gt;
&lt;p&gt;Compared to vibe coding, this approach keeps the AI aligned with defined requirements, produces documentation from day one, and frees the developer to focus on other work while the AI builds. As a practical example, the author built AgentD — a local service for scheduling and running AI agents — in about five hours without writing code by hand, a project that would have taken weeks manually. In his view, software engineers should shift their focus toward architectural thinking, requirements definition, and quality verification rather than competing with AI on raw coding speed.&lt;/p&gt;
&lt;h2 id="go-vs-java-the-minimalist-vs-the-enterprise-veteran"&gt;&lt;a href="https://dev.to/adamthedeveloper/go-vs-java-the-minimalist-vs-the-enterprise-veteran-1gg3" rel="noopener noreferrer"&gt;Go vs Java: The Minimalist vs The Enterprise Veteran&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two languages built on opposite philosophies: Go embraces radical minimalism (no classes, no inheritance, and no generics until 2022), while Java offers a rich toolkit of generics, inheritance, interfaces, and annotations. According to the author, Go&amp;rsquo;s minimalism lets new team members read and understand a codebase from day one. On performance, Go compiles to native binaries that start in milliseconds, making it a natural fit for containerized workloads; Java runs on the JVM, starting slower but warming up to high peak throughput thanks to JIT compilation in long-running services.&lt;/p&gt;
&lt;p&gt;The concurrency gap has narrowed considerably: Go&amp;rsquo;s goroutines and channels have long been lightweight and ergonomic, but Virtual Threads in Java 21 now bring M:N scheduling to Java&amp;rsquo;s familiar thread API, even if the underlying mechanics and trade-offs still differ from goroutines. In terms of ecosystem, Java boasts millions of mature libraries with Spring dominating enterprise development, while Go favors quality over quantity with a standard library sufficient for most tasks. Go shines for infrastructure, CLIs, microservices, and cloud-native apps; Java excels in complex enterprise systems. The author concludes that neither language is universally superior — the right choice depends on project requirements and team expertise.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-goal"&gt;&lt;a href="https://x.com/Saboo_Shubham_/status/2054988166541770782" rel="noopener noreferrer"&gt;The ultimate guide to /goal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shubham Saboo argues that &lt;code&gt;/goal&lt;/code&gt; is not just a feature, but is emerging as a foundational primitive for coding agents, much like HTTP or JSON. With normal prompting, you steer turn by turn: read the response, evaluate it, and nudge the agent to the next step. &lt;code&gt;/goal&lt;/code&gt; flips that model: you describe what &amp;ldquo;done&amp;rdquo; looks like, send it once, and the agent loops autonomously until it gets there — for example, &amp;ldquo;build the app according to SPEC.md; done means tests pass, build passes, README is accurate, and git status is clean.&amp;rdquo; It shifts the interaction from micromanaging steps to delegating against a clear objective. Notably, three separate ecosystems — OpenAI Codex CLI, Claude Code, and the Hermes Agent orchestrator — have converged on the same command pattern, making them composable.&lt;/p&gt;
&lt;p&gt;Saboo outlines three enduring roles regardless of how tools evolve: the orchestrator that coordinates, selects workers, manages the Kanban board, and performs final verification (Hermes); the builder that takes a spec and generates code (Codex&amp;rsquo;s strength); and the reviewer that hunts for bugs in plausible-looking code (Claude Code&amp;rsquo;s strength). The golden rule is independent verification: Hermes never trusts Codex&amp;rsquo;s self-reported completion and instead runs &lt;code&gt;npm test&lt;/code&gt; and &lt;code&gt;npm run build&lt;/code&gt; itself — turning &lt;code&gt;/goal&lt;/code&gt; from a promise into a contract. Multiple goals can run in parallel, though each file should only have a single writing agent at a time to avoid conflicts.&lt;/p&gt;
&lt;h2 id="the-ai-native-developer"&gt;&lt;a href="https://newsletter.getdx.com/p/the-ai-native-developer" rel="noopener noreferrer"&gt;The AI-Native Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck presents research on how AI is reshaping the developer role, drawing on a survey of more than 1,300 developers and interviews with 22 practitioners. Developer work falls into three buckets: core tasks like coding, debugging, and testing score high across every dimension and represent the biggest opportunity for AI; cross-component debugging and environment provisioning are areas where developers want deeper AI help, though current tools still fall short; and relational work like stakeholder communication sits in the &amp;ldquo;low priority for AI&amp;rdquo; zone where developers want to retain their own voice and final accountability.&lt;/p&gt;
&lt;p&gt;The study identifies four stages of AI maturity: Skeptics, who adopt only when competitive pressure forces their hand; Explorers, who build confidence through small wins; Collaborators, who bring AI into their workflow much earlier; and Strategists, who orchestrate multiple agents in parallel, shifting from code producers to &amp;ldquo;architects of intent.&amp;rdquo; Alongside this progression sit three unresolved tensions: the learning paradox (are we becoming better engineers or just better prompt writers?), the risk of skill atrophy among junior developers, and an accountability gap when verification standards fail to keep pace with generation speed. Houck sketches three possible futures: maintaining deep craft at AI speed, focusing on orchestration and judgment, or becoming a &amp;ldquo;Clerical Coder&amp;rdquo; who rubber-stamps generated code without truly understanding it.&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>