Enjoy Newsletter #79.

ASCII characters are not pixels: a deep dive into ASCII rendering

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’s solution is a “shape vector”: 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’s shape. With six staggered sampling circles, a 6-dimensional vector cleanly distinguishes p from q, or ^, -, and _; 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.

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.

From Bare Metal to Containers: A Developer’s Guide to Execution Environments

This guide explains why “it works on my machine” 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 (chroot, Linux capabilities, seccomp, bubblewrap) restrict what a single process is allowed to do to shrink its blast radius. Finally, language virtual environments like Python’s venv isolate only language-level packages, with ecosystems increasingly converging on unified toolchains like uv, Conda, or rustup with Cargo.

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?

Run Your Project in a Dev Container, in Zed

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 .devcontainer/devcontainer.json. When you open a project containing this file, Zed prompts you to reopen it inside the Dev Container; you can also trigger project: open remote, and Zed automatically reconnects to your last active container on relaunch.

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 docker exec. Container provisioning is delegated to the official devcontainer CLI (devcontainer up), which allowed the feature to ship quickly, though forwardPorts and Zed-specific extension declarations aren’t supported yet in this initial release. Upcoming work includes templates for authoring Dev Container specs directly inside Zed, declaring Zed extensions in devcontainer.json, and supporting forwardPorts once Zed moves to a native built-in implementation.

I was a top 0.01% Cursor user. Here’s why I switched to Claude Code 2.0

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.

The core of the post revolves around five pillars: context management (spawning subagents for parallel tasks, using /compact, 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 “rule of three”—if you’ve explained a bug three times and Claude still doesn’t get it, change your approach. He packages his workflow into two slash commands—/setup-claude-code (run once per machine) and /setup-repo (run once per project)—and shares how he runs 12 terminal sessions in parallel using hooks, skills, MCP servers, and headless mode.

LLM predictions for 2026, shared with Oxide and Friends

Simon Willison rounds up the 1-, 3-, and 6-year technology predictions he shared on the Oxide and Friends 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 “Challenger disaster” 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’s endangered Kākāpō parrot will enjoy a bumper breeding season.

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.

How we made Notion available offline

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 why each page is kept. A flat set of offline page IDs fell apart once automatic downloads (like recent and favorite pages) and “offline inheritance” 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, offline_page and offline_action, where each row in offline_action represents a distinct retention reason.

To keep offline pages fresh without polling the server—which wouldn’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 lastDownloadedTimestamp against the server’s lastUpdatedTime 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 offline_action and applies the minimal set of edits, keeping the local forest eventually consistent with the workspace without rebuilding from scratch.

How Browsers Work

How Browsers Work 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 "pizza" is turned into a search engine query URL, while "example.com" is normalized into https://example.com. That URL is then formatted into an HTTP request with headers like Host; 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 (SYN, SYN-ACK, ACK), using sequence numbers to ensure bytes arrive in order and lost packets are retransmitted.

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.

Verdict: I’m not sure why, but I feel like this issue turned out pretty well^^ Probably because I updated AGENTS.md yesterday—let’s keep the momentum going :)))


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.