<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Developer Tools on miti99</title><link>https://miti99.com/en/tags/developer-tools/</link><description>Recent content in Developer Tools 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/developer-tools/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #80</title><link>https://miti99.com/en/post/2026/02/03/</link><pubDate>Tue, 03 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #80.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-agent-skills-directory"&gt;&lt;a href="https://www.skills.sh/" rel="noopener noreferrer"&gt;The Agent Skills Directory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Skills.sh is an open directory of reusable skills for AI coding agents. Each skill packages procedural knowledge for a specific domain—such as UI design workflows, React and Next.js best practices, code review checklists, or debugging playbooks—and can be installed into an agent with a single command (&lt;code&gt;npx skills add ...&lt;/code&gt;). Instead of figuring out workflows from scratch on every session, agents gain instant access to standardized, battle-tested instructions.&lt;/p&gt;
&lt;p&gt;The site features a leaderboard ranked by total installs alongside 24-hour trending and rising categories, making it easy to discover skills for your stack. It is a community-driven ecosystem where anyone can publish and share skills alongside official skill packs from companies like Vercel, Anthropic, Expo, and Supabase. For developers getting started with coding agents, it offers a convenient way to equip agents with capabilities spanning coding, testing, deployment, and operations.&lt;/p&gt;
&lt;h2 id="results-from-the-2025-go-developer-survey"&gt;&lt;a href="https://go.dev/blog/survey2025" rel="noopener noreferrer"&gt;Results from the 2025 Go Developer Survey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Go team published the results of the 2025 Go Developer Survey, gathering responses from 5,379 developers. Three headline findings stood out: Go developers want more guidance on identifying and applying Go best practices, getting the most out of the standard library, and seeing more modern features in the language and toolchain; most respondents already use AI-powered coding tools to look up information or generate boilerplate, but overall satisfaction with AI tools remains lukewarm; and a surprising share of developers regularly have to look up documentation for everyday commands like &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go mod&lt;/code&gt;, highlighting room for improvement in the &lt;code&gt;go&lt;/code&gt; CLI&amp;rsquo;s built-in help system.&lt;/p&gt;
&lt;p&gt;Overall sentiment remains strong: 91% of respondents are satisfied working with Go, with nearly two-thirds &amp;ldquo;very satisfied&amp;rdquo;—a figure that has held steady since 2019. The top three pain points are writing idiomatic Go code, missing features familiar from other languages, and finding trustworthy third-party modules. On AI tooling, 53% use AI assistants daily, yet only 13% report being &amp;ldquo;very satisfied,&amp;rdquo; primarily because generated code frequently fails to compile or is low quality. CLI tools and API/RPC services remain the most common workloads, with 55% of respondents building both; over a third build cloud infrastructure tooling, and 11% work on ML models, tools, or agents. On development environments, 60% develop on macOS and 58% on Linux, while 96% deploy to Linux targets.&lt;/p&gt;
&lt;h2 id="an-honest-review-of-go"&gt;&lt;a href="https://benraz.dev/blog/golang_review.html" rel="noopener noreferrer"&gt;An Honest Review of Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming from a Rust background, the author shares his candid impressions after a few months of building small projects in Go. Go&amp;rsquo;s standout strength is concurrency: goroutines and channels are baked right into the language, are effortless to use, and avoid the &amp;ldquo;colored functions&amp;rdquo; problem (&lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; contagion) that plagues many other concurrency models. The type system is intentionally minimal with no complex inheritance hierarchies; struct embedding is essentially syntactic sugar. Because types implement interfaces implicitly without an explicit declaration, functions like &lt;code&gt;Printf&lt;/code&gt; and template libraries are easy to write without needing macros. He also appreciates Go&amp;rsquo;s clean syntax and its capitalization-based visibility rules.&lt;/p&gt;
&lt;p&gt;On the flip side, Go has notable rough edges. The language lacks true enums: the idiomatic workaround using &lt;code&gt;const&lt;/code&gt; and &lt;code&gt;iota&lt;/code&gt; doesn&amp;rsquo;t enforce a closed set of values, and &lt;code&gt;switch&lt;/code&gt; statements don&amp;rsquo;t check for exhaustiveness. Go also lacks true immutability, since &lt;code&gt;const&lt;/code&gt; only supports compile-time primitives and any exported package-level &lt;code&gt;var&lt;/code&gt; can be mutated by callers. Finally, the &lt;code&gt;error&lt;/code&gt; type is just a bare interface with an &lt;code&gt;Error() string&lt;/code&gt; method, making it easy to obscure structured failure details; even with &lt;code&gt;errors.Is&lt;/code&gt; and &lt;code&gt;errors.As&lt;/code&gt;, he finds Go&amp;rsquo;s error handling far less expressive than Rust&amp;rsquo;s enums and sum types.&lt;/p&gt;
&lt;h2 id="the-challenges-of-soft-delete"&gt;&lt;a href="https://atlas9.dev/blog/soft-delete.html" rel="noopener noreferrer"&gt;The challenges of soft delete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Soft delete—adding an &lt;code&gt;archived_at&lt;/code&gt; or &lt;code&gt;deleted&lt;/code&gt; column to a database table—looks deceptively simple at first, but introduces compounding complexity over time. Dead data accumulates indefinitely even though 99% of archived rows are never read again; every query, view, and unique index must remember to filter out soft-deleted rows; schema migrations have to account for stale historical records; and restoring a deleted record is rarely as simple as setting &lt;code&gt;archived_at = null&lt;/code&gt; when external systems and side effects are involved.&lt;/p&gt;
&lt;p&gt;The author evaluates three PostgreSQL alternatives that separate archived data from live operational tables. First is application-level archiving: emitting a deletion event for a separate service to persist, which keeps the primary database lean but risks data loss on failure and requires extra infrastructure. Second is a &lt;code&gt;BEFORE DELETE&lt;/code&gt; database trigger that copies the deleted row into a JSONB archive table, keeping live tables clean and making retention cleanup trivial. Third is Change Data Capture (CDC) from the write-ahead log (WAL) using tools like Debezium, which requires zero application code changes but adds operational complexity and can fill up the primary server&amp;rsquo;s disk if the consumer falls behind. He also floats an untested idea of a replication follower configured to ignore &lt;code&gt;DELETE&lt;/code&gt; statements. Starting a new project today, he would pick the trigger approach because it is easy to set up, requires no extra infrastructure, and keeps archived rows queryable whenever needed.&lt;/p&gt;
&lt;h2 id="i-got-paid-minimum-wage-to-solve-an-impossible-problem"&gt;&lt;a href="https://tiespetersen.substack.com/p/i-got-paid-minimum-wage-to-solve" rel="noopener noreferrer"&gt;I got paid minimum wage to solve an impossible problem.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Computer science student Ties Petersen had a minimum-wage part-time job sweeping the floors of an Albert Heijn supermarket. Instead of just pushing a broom, he modeled the store floorplan as a grid graph, built a visual editor in Processing, and wrote a C++ route optimizer using simulated annealing with 2-opt swaps—essentially solving a variant of the Traveling Salesperson Problem. His first &amp;ldquo;optimal&amp;rdquo; route was nearly as short as mathematically possible, yet completely useless in practice because it was full of sharp zig-zag turns nobody could physically push a broom through. The algorithm did exactly what was asked; the question itself was wrong. Once he added a &amp;ldquo;turn penalty&amp;rdquo; to the cost function, the route became smooth and walkable at the cost of a slightly longer distance—tuning that penalty was all about balancing theoretical efficiency against physical reality.&lt;/p&gt;
&lt;p&gt;From there, he zooms out to the broader tech industry: social media algorithms optimize for engagement rather than human well-being, recommendation engines optimize for watch time until users spend six hours down conspiracy rabbit holes, large language models optimize for sounding confident rather than being truthful, and corporations optimize for quarterly profit while ignoring environmental and ethical externalities. His core takeaway: technical precision is meaningless if you&amp;rsquo;re solving the wrong problem, so defining what you are actually optimizing for is the most important step of all.&lt;/p&gt;
&lt;h2 id="command-completion--in-intellij-idea"&gt;&lt;a href="https://foojay.io/today/command-completion-intellij-idea/" rel="noopener noreferrer"&gt;Command completion (..) in IntelliJ IDEA&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Command completion (&lt;code&gt;..&lt;/code&gt;) is a new feature in IntelliJ IDEA that extends familiar code completion so you can discover and execute IDE actions right inside the editor without memorizing keyboard shortcuts. Typing a single dot &lt;code&gt;.&lt;/code&gt; surfaces context-aware IDE commands alongside standard API suggestions and postfix completions, while typing two dots &lt;code&gt;..&lt;/code&gt; filters the popup exclusively to IDE commands and lets you search through them. You can use it to fix errors and warnings with richer previews than &lt;code&gt;Alt+Enter&lt;/code&gt;, run file-level actions like reformatting code or optimizing imports on any blank line, generate classes, methods, fields, or &lt;code&gt;toString()&lt;/code&gt;, and convert a class into a modern Java &lt;code&gt;record&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;It also supports navigation, renaming via &lt;code&gt;..rename&lt;/code&gt;, extracting methods, introducing local variables, and adding Javadoc comments—and you can enable it in read-only files via settings to jump to implementations or find usages. Many commands include natural aliases, such as &lt;code&gt;..change name&lt;/code&gt; for &lt;code&gt;..rename&lt;/code&gt;, so you don&amp;rsquo;t need to remember exact action names. Command completion complements rather than replaces keyboard shortcuts, postfix completion, and live templates, helping you stay in flow, focus on &lt;em&gt;what&lt;/em&gt; you want to do rather than &lt;em&gt;how&lt;/em&gt; to trigger it, and discover powerful IDE features along the way.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/8d53556e-5fbc-4ceb-ac64-cc5f3b211c5d_2250x2624.png" alt="The Must-Know Fundamentals of Distributed Systems"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yb_V!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F16cec58a-02f8-4daf-8669-d1208ac5fc18_2360x2960.jpeg" alt="What Happens When You Enter Google.com"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LIIv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F631f49cf-2eff-4941-ba22-b2c482eb24ec_2360x2960.png" alt="Understanding the Linux Directory Structure"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gxq4!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F11498f7e-5457-425f-9d50-90f5ebc31187_2360x2960.jpeg" alt="Symmetric vs. Asymmetric Encryption"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!XFaF!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5140ecd2-ac9e-46d1-bde6-00f727309778_800x1003.jpeg" alt="Network Troubleshooting Test Flow"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=oP6DS_x5K0Y" rel="noopener noreferrer"&gt;What Are AI Agents &amp;amp; How Do They Work?&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 #79</title><link>https://miti99.com/en/post/2026/02/02/</link><pubDate>Mon, 02 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #79.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ascii-characters-are-not-pixels-a-deep-dive-into-ascii-rendering"&gt;&lt;a href="https://alexharri.com/blog/ascii-rendering" rel="noopener noreferrer"&gt;ASCII characters are not pixels: a deep dive into ASCII rendering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Harri shares how he built an image-to-ASCII renderer that produces crisp, sharp edges. The conventional approach divides an image into a grid, computes the average brightness of each cell, and picks a character by density; even with supersampling inside each cell for anti-aliasing, the result looks blurry because every character is treated as a uniform pixel and its internal geometry is ignored. Harri&amp;rsquo;s solution is a &amp;ldquo;shape vector&amp;rdquo;: placing sampling circles inside each character cell, measuring how much of each glyph overlaps each circle, and using those values as a vector describing the character&amp;rsquo;s shape. With six staggered sampling circles, a 6-dimensional vector cleanly distinguishes &lt;code&gt;p&lt;/code&gt; from &lt;code&gt;q&lt;/code&gt;, or &lt;code&gt;^&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, and &lt;code&gt;_&lt;/code&gt;; at render time, the engine samples each image cell the exact same way and picks the character with the nearest normalized vector by Euclidean distance.&lt;/p&gt;
&lt;p&gt;To make boundaries between regions of different brightness pop even more, he adds two contrast-enhancement passes: global contrast enhancement (normalizing the sample vector and raising its components to an exponent to push darker regions down) and directional contrast enhancement (using external sampling circles reaching just outside the cell), eliminating staircase artifacts along edges. The appendices cover performance: k-d trees to accelerate nearest-neighbor lookups, caching with bit-packed quantized keys, and offloading sampling to a GPU shader for smooth real-time rendering on mobile. As he notes, using multi-dimensional vectors to represent geometric shape applies to many other domains, much like word embeddings in NLP.&lt;/p&gt;
&lt;h2 id="from-bare-metal-to-containers-a-developer"&gt;&lt;a href="https://buildsoftwaresystems.com/post/guide-to-execution-environments/" rel="noopener noreferrer"&gt;From Bare Metal to Containers: A Developer&amp;rsquo;s Guide to Execution Environments&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide explains why &amp;ldquo;it works on my machine&amp;rdquo; bugs usually stem from differences in execution environments, walking from the heaviest isolation layers down to the lightest. Bare metal gives you direct hardware control and zero virtualization overhead, at the cost of managing hardware and resource isolation yourself. Virtual machines use a hypervisor to carve a physical server into independent machines, each running its own guest OS kernel—providing strong isolation at a higher resource cost. Containers package an application with its userland dependencies while sharing the host OS kernel via Linux namespaces and cgroups, starting quickly with lighter isolation. Process sandboxes (&lt;code&gt;chroot&lt;/code&gt;, Linux capabilities, &lt;code&gt;seccomp&lt;/code&gt;, &lt;code&gt;bubblewrap&lt;/code&gt;) restrict what a single process is allowed to do to shrink its blast radius. Finally, language virtual environments like Python&amp;rsquo;s &lt;code&gt;venv&lt;/code&gt; isolate only language-level packages, with ecosystems increasingly converging on unified toolchains like &lt;code&gt;uv&lt;/code&gt;, Conda, or &lt;code&gt;rustup&lt;/code&gt; with Cargo.&lt;/p&gt;
&lt;p&gt;The central takeaway is that every tool draws its own isolation boundary, and every layer below that boundary must already be compatible: a container cannot fix a kernel mismatch, and a language virtual environment cannot compensate for a missing system C library. In practice these layers are stacked—for example, a cloud VM running Docker, with a language virtual environment inside the container. The post also touches on serverless platforms and WebAssembly as newer isolation boundaries, leaving readers with a guiding question for picking the right tool: what is the lowest layer that needs to be identical for your code to run?&lt;/p&gt;
&lt;h2 id="run-your-project-in-a-dev-container-in-zed"&gt;&lt;a href="https://zed.dev/blog/dev-containers" rel="noopener noreferrer"&gt;Run Your Project in a Dev Container, in Zed&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Starting in v0.218, Zed supports working inside Dev Containers, an open specification for defining Docker-based development environments. Instead of relying on tribal knowledge or an easily outdated README for tool versions, databases, and environment variables, teams describe their setup as code in &lt;code&gt;.devcontainer/devcontainer.json&lt;/code&gt;. When you open a project containing this file, Zed prompts you to reopen it inside the Dev Container; you can also trigger &lt;code&gt;project: open remote&lt;/code&gt;, and Zed automatically reconnects to your last active container on relaunch.&lt;/p&gt;
&lt;p&gt;Under the hood, Zed reuses the remote development architecture it originally built for SSH: a headless Zed Remote Server runs inside the container to handle file operations, language servers, and syntax analysis, while the local Zed client renders the UI; because the two communicate over standard input/output, supporting containers only required adding a transport layer over &lt;code&gt;docker exec&lt;/code&gt;. Container provisioning is delegated to the official &lt;code&gt;devcontainer&lt;/code&gt; CLI (&lt;code&gt;devcontainer up&lt;/code&gt;), which allowed the feature to ship quickly, though &lt;code&gt;forwardPorts&lt;/code&gt; and Zed-specific extension declarations aren&amp;rsquo;t supported yet in this initial release. Upcoming work includes templates for authoring Dev Container specs directly inside Zed, declaring Zed extensions in &lt;code&gt;devcontainer.json&lt;/code&gt;, and supporting &lt;code&gt;forwardPorts&lt;/code&gt; once Zed moves to a native built-in implementation.&lt;/p&gt;
&lt;h2 id="i-was-a-top-001-cursor-user-here"&gt;&lt;a href="https://blog.silennai.com/claude-code" rel="noopener noreferrer"&gt;I was a top 0.01% Cursor user. Here&amp;rsquo;s why I switched to Claude Code 2.0&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author—who has coded with AI since 2021, contributed early on to AutoGPT, and was ranked in the top 0.01% of Cursor users—explains why he switched to Claude Code: in his view, Claude Opus 4.5 elevated programming to a higher level of abstraction where you verify behavior rather than reading every line of code. Claude Code fits an asynchronous, terminal-native workflow, is purpose-tuned for Claude models, is cost-effective, and is easy to customize; Cursor still has its place for pixel-perfect UI tweaks, learning a new codebase, or making small targeted edits.&lt;/p&gt;
&lt;p&gt;The core of the post revolves around five pillars: context management (spawning subagents for parallel tasks, using &lt;code&gt;/compact&lt;/code&gt;, starting fresh sessions before quality degrades, and sticking to one task per session); planning (using plan mode, sprint-style task lists, or doing a dry run and reverting to refine the plan); closing the loop by automating every repetitive check; verifiability via automated UI testing; and systematic debugging using the &amp;ldquo;rule of three&amp;rdquo;—if you&amp;rsquo;ve explained a bug three times and Claude still doesn&amp;rsquo;t get it, change your approach. He packages his workflow into two slash commands—&lt;code&gt;/setup-claude-code&lt;/code&gt; (run once per machine) and &lt;code&gt;/setup-repo&lt;/code&gt; (run once per project)—and shares how he runs 12 terminal sessions in parallel using hooks, skills, MCP servers, and headless mode.&lt;/p&gt;
&lt;h2 id="llm-predictions-for-2026-shared-with-oxide-and-friends"&gt;&lt;a href="https://simonwillison.net/2026/Jan/8/llm-predictions-for-2026/" rel="noopener noreferrer"&gt;LLM predictions for 2026, shared with Oxide and Friends&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison rounds up the 1-, 3-, and 6-year technology predictions he shared on the &lt;em&gt;Oxide and Friends&lt;/em&gt; podcast. Within one year: the quality of LLM-written code will become undeniable, as his own hand-typed code has already dropped below 10% since the release of Claude Opus 4.5 and GPT-5.2; the sandboxing problem will largely be solved, with containers and WebAssembly as the two most promising contenders; we will see a &amp;ldquo;Challenger disaster&amp;rdquo; for coding agent security because so many developers casually run agents in YOLO mode with near-root privileges—for instance, a prompt-injection worm spreading through Python or npm packages; and, on a lighter note, New Zealand&amp;rsquo;s endangered Kākāpō parrot will enjoy a bumper breeding season.&lt;/p&gt;
&lt;p&gt;Within three years, the Jevons paradox debate for coding agents will be settled one way or the other: software engineering skills will either depreciate or become even more valuable as demand for custom software multiplies; and someone building a working web browser mostly with AI will no longer raise eyebrows, thanks to comprehensive conformance test suites. Within six years, typing code by hand will go the way of punch cards, yet software engineering will remain a major profession because building reliable software still demands deep skill, judgment, and experience.&lt;/p&gt;
&lt;h2 id="how-we-made-notion-available-offline"&gt;&lt;a href="https://www.notion.com/blog/how-we-made-notion-available-offline" rel="noopener noreferrer"&gt;How we made Notion available offline&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Notion shares the engineering behind Offline Mode, their most requested feature for years. Previously, the app used local SQLite caching on a best-effort basis with no completeness guarantees; true offline mode required guaranteeing that an entire page is usable without a network connection, elevating the local cache into a persistent storage layer that tracks which pages are available offline, stores every record needed to render them, and records &lt;em&gt;why&lt;/em&gt; each page is kept. A flat set of offline page IDs fell apart once automatic downloads (like recent and favorite pages) and &amp;ldquo;offline inheritance&amp;rdquo; from parent pages entered the picture: a single page can have multiple independent reasons to stay offline and should only be evicted when the very last reason goes away. Notion solved this by modeling a forest of offline page trees across two SQLite tables, &lt;code&gt;offline_page&lt;/code&gt; and &lt;code&gt;offline_action&lt;/code&gt;, where each row in &lt;code&gt;offline_action&lt;/code&gt; represents a distinct retention reason.&lt;/p&gt;
&lt;p&gt;To keep offline pages fresh without polling the server—which wouldn&amp;rsquo;t scale—the server publishes invalidation events on per-page channels whenever a page changes, and clients subscribe to channels for their offline pages to fetch deltas. Upon reconnecting after being offline, the client compares &lt;code&gt;lastDownloadedTimestamp&lt;/code&gt; against the server&amp;rsquo;s &lt;code&gt;lastUpdatedTime&lt;/code&gt; so it only re-downloads pages that actually changed. And when pages move or database rows are added or removed, a forest reconciliation pass diffs the new tree snapshot against &lt;code&gt;offline_action&lt;/code&gt; and applies the minimal set of edits, keeping the local forest eventually consistent with the workspace without rebuilding from scratch.&lt;/p&gt;
&lt;h2 id="how-browsers-work"&gt;&lt;a href="https://howbrowserswork.com/" rel="noopener noreferrer"&gt;How Browsers Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;How Browsers Work&lt;/em&gt; is an open-source interactive guide by Caleb Hearth for engineers and everyday web users who want a concrete mental model of what happens inside a browser; it uses bite-sized interactive simulations and intentionally omits rabbit holes like HTTP version differences or TLS handshakes. The journey starts at the address bar: an arbitrary string like &lt;code&gt;&amp;quot;pizza&amp;quot;&lt;/code&gt; is turned into a search engine query URL, while &lt;code&gt;&amp;quot;example.com&amp;quot;&lt;/code&gt; is normalized into &lt;code&gt;https://example.com&lt;/code&gt;. That URL is then formatted into an HTTP request with headers like &lt;code&gt;Host&lt;/code&gt;; the browser queries DNS to resolve the domain name to an IP address and, in the illustrated HTTP-over-TCP model, establishes a connection via the three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;), using sequence numbers to ensure bytes arrive in order and lost packets are retransmitted.&lt;/p&gt;
&lt;p&gt;When the HTTP response streams back, the browser splits the headers from the body and feeds the HTML into a streaming, error-tolerant parser to construct the DOM tree—the in-memory document model that acts as the shared contract between the HTML parser, CSS selectors, and JavaScript. Finally comes the rendering pipeline: Layout computes box sizes and positions, Paint fills in pixels, and Composite layers them together on the GPU. Not every change triggers the full pipeline: changing a color usually only requires repainting, whereas changing element dimensions forces a layout recalculation—which is why layout-heavy pages feel noticeably slower.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;I&amp;rsquo;m not sure why, but I feel like this issue turned out pretty well^^ Probably because I updated &lt;code&gt;AGENTS.md&lt;/code&gt; yesterday—let&amp;rsquo;s keep the momentum going :)))&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>