Enjoy Newsletter #136.

Fast and Hard Code

Armin Ronacher observes that regardless of how far you buy into the “coding is solved” meme, the human learning curve of a programming language no longer acts as the gatekeeper it once did—because human syntax friction doesn’t slow down an AI agent. As a result, LLMs make initial language choice simultaneously less permanent (if you don’t like a codebase, you can port it to another language over a weekend, even one you barely know) and more driven by a language’s runtime characteristics and cultural aspirations. He sees developers shipping Rust today who would never have invested the months required to wrestle with the borrow checker by hand. Two trends reinforce this shift: a renewed appreciation for fast, resource-frugal software, and the realization that LLMs are exceptionally good at low-level performance optimization when given a benchmark and a test suite to keep behavior identical.

Performance-obsessed builders like Mitchell Hashimoto, Charlie Marsh, Jarred Sumner, and Daniel Lemire have all embraced agentic workflows, and automated optimization loops let anyone hand a hot function to an agent and ask it to hill-climb on throughput. Consequently, new projects that care about speed and binary size increasingly reach for “hard” systems languages. Even Zig is benefiting—despite its core community’s skepticism toward AI: Cloudflare’s Artifacts service runs a full Git protocol engine written in Zig and compiled to a ~100 KB WebAssembly module, and Vercel recently shipped fx, a coding agent written in Zig. Developers are also tackling intimidating domains like DWARF debug info, eBPF, custom network drivers, cryptography, and retro hardware that used to feel out of reach. The AI era may produce plenty of slop, Ronacher concludes, but it is also empowering a wave of fast, uncompromising systems software.

Shipping Video Calling on Facebook

Philip Su looks back 16 years to when he joined Facebook’s fledgling Seattle office as its second engineer after twelve years at Microsoft. At the time, Facebook had only around 500 engineers in total, and Su signed up as the sole full-time engineer building Facebook’s very first video calling product—later joined by teammates like Denise Noyes and Vijaye Raji—small enough that the team reviewed product iterations directly with Mark Zuckerberg. Because WebRTC didn’t exist yet, Facebook partnered with Skype to embed a downloadable native Skype client binary that users installed before placing a call. Su pulls no punches about the quality of Skype’s codebase at the time: call setup succeeded only 82% of the time, and when he asked Skype’s engineers what their own baseline call-setup success rate was, they replied, “We don’t track that metric”—relying solely on post-call user star ratings. Ironically, routing call-signaling packets over Facebook Messenger’s infrastructure exposed that Messenger itself was silently dropping messages at a surprising rate, forcing Facebook to harden its own real-time messaging backbone.

The six weeks following launch were the most grueling crunch of Su’s career: shipping hotfix after hotfix from 8 a.m. to midnight seven days a week, subsisting on office junk food, and somehow still losing over 10 pounds from the stress. One fun Easter egg: the outgoing ringtone melody was literally the musical notes F–A–C–E. By the end of that six-week blitz, call reliability was solid, and Su used the feature to have his very first video call with his parents—a technology that COVID and WebRTC have since made as mundane as a phone call.

AI is removing the middle class of software engineering

Florian Herrengt opens with a scene that has become all too familiar in 2026: a senior engineer logs in on Monday morning to find seven pull requests waiting for review, the first of which is a 24,000-line diff accompanied by an AI-generated summary. When a subtle bug crops up for the fourth time, the developer who opened the PR can’t explain where the data originates—their only move is to paste the stack trace back into Claude. In Herrengt’s view, AI has removed the natural speed limit of software development: teams with weak engineering culture now drive off a cliff ten times faster, and the tragedy is that to an inexperienced eye, the app still looks like it works. Undoing a bad architectural decision is much harder than generating it—an LLM can add three unnecessary database tables in ten minutes, but untangling them once real customer data lands in production requires a painful, high-risk migration.

Weak code has always existed, Herrengt notes, but the difference today is velocity—like crashing a car at 200 km/h instead of 30 km/h. Code review, tests, and CI pipelines still exist, but they were designed for a world where human typing speed naturally throttled the volume of changes entering the pipe. A developer churning out ten massive AI-generated PRs a day isn’t necessarily creating value; they are often just shifting the cognitive burden onto the team’s most senior, hardest-to-replace engineers. He predicts AI will hollow out the middle of the engineering market and widen compensation gaps: strong engineers with deep system judgment become exponentially more valuable, while developers who use AI as a substitute for understanding rather than an amplifier of it will struggle to stay employable.

The fastest double-to-string algorithm you’ve never heard of

Victor Zverovich, author of {fmt} and the zmij floating-point formatting library, spotlights one of the fastest dtoa (double-to-string) algorithms in existence—one that almost nobody has heard of. It lives quietly inside yy_double.c in ibireme’s yyjson C library, has no accompanying academic paper, and has no formal name beyond its filename prefix, so Zverovich simply calls it “yy”. In fact, Zverovich’s own zmij library started out as an optimized port of the Schubfach algorithm before he swapped its core over to yy. Like Ryū, Dragonbox, and Schubfach, yy solves the shortest-roundtrip formatting problem: finding the shortest decimal representation that parses back to the exact same IEEE 754 binary floating-point number by picking the coarsest decimal grid that lands inside the value’s rounding interval.

What makes yy remarkably fast is that it needs only a single 128-bit multiplication by a precomputed power of 10 in the common case, whereas classic Schubfach requires two or three 192-bit multiplications. For a given double, yy estimates the decimal exponent via a fixed-point approximation of $\log_{10}(2)$, scales the significand once, and evaluates four candidate decimal values—two on the fine grid and two on the coarse (multiples of 10) grid. Three simple predicates select the winner, preferring a shorter coarse-grid candidate whenever it falls inside the rounding interval. Half-ULP interval bounds are derived via cheap bit shifts rather than extra multiplications, and round-half-to-even ties are resolved by checking the least significant bit of the original significand. Zverovich includes an interactive visualization on 8-bit E4M3 floats to show how edge cases like 192 format cleanly as "2e2" instead of "19e1", concluding that brilliant algorithms buried inside practical open-source libraries deserve the same recognition as those published in academic venues.

Quake Shareware, a CD-ROM just a little too full

Fabien Sanglard tells the story of id Software’s infamous 1996 Quake shareware CD-ROM. In the mid-1990s, a 640 MiB CD-ROM held vastly more space than a typical game needed. Because the Quake shareware episode took up only 22 MiB, id Software decided to fill the remaining ~600 MiB with encrypted full retail versions of Quake and their entire back catalog (DOOM, DOOM II, Final DOOM, Heretic, Hexen). Players could buy the disc at retail for $9.95, play the shareware episode, call 1-800-ID-GAMES, read a dynamic CHALLENGE code over the phone, pay by credit card, and receive an unlock SERIAL code—with the challenge changing on every run to prevent customers from sharing a single unlock code with friends. The DRM wrapper, provided by TestDrive Corporation, “denatured” each game’s .EXE by overwriting its first 32 KiB and storing the encrypted original header in a companion file. Yet just 39 days after the CD hit store shelves, the cracking group GNOMON released QCRACK.EXE, a tiny keygen that computed valid SERIAL codes from any CHALLENGE for every game on the disc—leaving id Software stuck with nearly 150,000 unsold CDs in a warehouse.

Reverse-engineering the installer executable FLOW.EXE reveals why the scheme collapsed instantly: the unlock SERIAL didn’t actually contain the decryption key! The symmetric decryption key was already sitting right inside FLOW.EXE on the disc; the installer simply ran the exact same hash function on the CHALLENGE string to generate the expected SERIAL locally and compared it against what the user typed—pure security by obscurity. Worse still, Sanglard discovered that Final DOOM couldn’t even be unlocked legitimately via the phone center because of a capitalization typo ("Final" vs "FINAL") in the encrypted catalog metadata file SKU.17—which itself was accompanied by an unencrypted plain-text copy, SKU.TXT, left right on the mastered CD by mistake. Sanglard attributes the blunders to “Fab’s Razor”: never attribute to stupidity what can be adequately explained by crunch-time deadline pressure.

How Instacart Built a Modern Search Infrastructure on Postgres

Instacart’s search engineering team recounts migrating their core product search infrastructure—spanning billions of grocery items across thousands of retailers, millions of daily searches, and billions of daily price, inventory, and promotion updates—off Elasticsearch and onto PostgreSQL. Originally, full-text search ran on Elasticsearch, but its denormalized document model meant every inventory or price change triggered massive partial-document re-indexing across the cluster, overwhelming write capacity and making data-repair backfills take days. By moving to a sharded, highly normalized PostgreSQL architecture using GIN indexes and a custom C extension for ts_rank, Instacart cut write amplification by 10x, gained the ability to index hundreds of gigabytes of ML ranking features in separate tables joined at query time via SQL, and cut search latency in half by pushing scoring computation down next to NVMe storage rather than hauling large document payloads up to the application tier.

In 2021, the team added semantic vector search via a standalone FAISS approximate-nearest-neighbor (ANN) service using MiniLM embeddings, blending lexical and vector results in the application tier. However, splitting retrieval across two systems forced the FAISS service to overfetch thousands of candidates before filtering out out-of-stock items, complicated relevance tuning, and required maintaining two distributed data pipelines in sync. Their final evolution unified both lexical and vector retrieval inside PostgreSQL using pgvector, allowing real-time inventory availability to act as a native SQL filter alongside vector similarity. By consolidating hundreds of per-retailer HNSW indexes into cohort indexes grouped by retailer size, tuning parallel query workers, and storing quantized embeddings PLAIN (inline) rather than in TOAST tables, pgvector delivered superior recall at comparable latency—cutting zero-result searches by 6% in A/B tests and driving a major lift in gross transaction value.

curl performance

curl creator Daniel Stenberg shares how the project finally launched a public continuous performance dashboard at curl.se/perf after years of the idea sitting on the wishlist because nobody had time to build an elaborate benchmarking platform. After finding Grafana too heavy for what he wanted, Stenberg decided not to let perfection be the enemy of good and built the entire pipeline using tools he already knew inside out. Because shared cloud CI runners are too noisy for repeatable performance measurements, the benchmarks run on a dedicated multi-core machine sitting in his own office. Every twenty minutes, a cron job triggers a shell script that pulls the latest git commits, compiles curl, and runs 24 microbenchmarks—measuring metrics like throughput when transferring 100 GB over localhost and the exact count and byte total of malloc/calloc/strdup heap allocations during an HTTP download. A second script parses the logs and generates static SVG graphs with gnuplot, pushing the updated dashboard straight to the website. Within hours of the page going live, contributors were already submitting patches to shave allocations and speed up hot paths.

Each commit is tested across multiple runs, plotting minimum, median, and maximum values. Because OS packages, kernel versions, and third-party TLS libraries inevitably shift over months, raw timings are most useful in the short term for catching accidental regressions immediately. To guard against slow “boiling frog” bloat over the long term, Stenberg added manually configured threshold “stakes” for key metrics, paired with Largest-Triangle-Three-Buckets (LTTB) downsampling for long-range charts and Mann-Kendall / Sen’s Slope statistical tests to flag gradual upward trends automatically. Even early on, the dashboard surfaced an instructive trade-off: a PR that reduced the number of heap allocations had accidentally bloated the size of curl’s main session struct.

Compression is prediction

Annie Sexton at ngrok takes readers on an interactive visual tour of information theory to explain a profound equivalence: data compression is prediction, and large language models are data compressors. Compression works by exploiting statistical redundancy—from simple run-length encoding (AAAAAB → 5A1B) to modern codecs composed of three stages: a transform that exposes patterns, a model that predicts a probability distribution for the next symbol, and an entropy coder that turns those probabilities into bits. While Huffman coding (used in gzip and Brotli) assigns shorter bitstrings to more frequent symbols, it can never use fewer than 1 bit per symbol; arithmetic coding overcomes that limit by subdividing the interval $[0, 1)$ proportionally to each symbol’s predicted probability, encoding an entire message as a single high-precision binary fraction that approaches Shannon’s theoretical entropy limit ($-\log_2 P$).

The better your model predicts the next symbol given prior context, the fewer bits the entropy coder needs: the letter U is relatively rare in English overall, yet nearly 100% certain right after Q, costing almost zero bits to encode when the model knows that context. That is the exact objective an LLM is trained on: predicting a probability distribution over the next token, where the cross-entropy loss function literally measures how many bits an arithmetic coder would need to encode the true next token using the model’s predictions. On a passage from Charles Dickens, a simple first-order Markov model compresses the text to 24% of its original size, whereas pairing GPT-2 with an arithmetic coder shrinks it to 10%. We don’t replace zstd with LLMs for everyday file archiving only because both sender and receiver would need gigabytes of model weights and heavy GPU compute—but mathematically, training a better predictor and building a tighter compressor are the exact same problem.

How Anthropic Builds And How Engineering Will Change Soon

Ryan Peterman interviews Thariq Shihipar, an engineer on Anthropic’s Claude Code team, about how engineers inside Anthropic work with frontier models every day. Shihipar’s first piece of advice for new hires is to treat Claude as a thought partner, feed it rich context, and constantly look to step up one level of abstraction: instead of just using the model to write a feature, build the system or skill that enables the model to build that whole class of features reliably. He argues that harnesses are becoming more important, not less: the smarter a model gets and the longer it runs autonomously, the more sophisticated the surrounding software—like Auto mode, sandboxes, and interactive Artifacts—needs to be so the agent can act safely and present its work clearly to humans. In his own daily workflow, he pairs Claude Fable for open-ended planning, brainstorming, and spec writing with Claude Opus 5 for disciplined implementation, and uses “loop engineering” (automated systems that prompt Claude on a schedule or trigger) to stay on top of bug queues and maintenance work that teams previously lacked bandwidth to touch.

On writing internal docs, his personal rule is simple: never send AI-generated text unless you would be completely comfortable sharing the exact prompt that produced it; let Claude draft data-heavy status reports, but write strategy memos and opinionated essays yourself. For codebase hygiene, nitpicking variable names and style conventions matters less in an agentic world than investing in automated simplification skills and writing roughly 100x more automated tests—especially request-replay harnesses and chaos testing—to keep incident rates down as commit velocity climbs. Learning how to code remains as valuable as ever: only someone who deeply understands systems can judge whether software is actually good, and “coding is solved” simply means translating a clear spec into working syntax is no longer the unpredictable bottleneck it used to be.

A faster way to convert a timestamp ➜ Hour, Min, Sec

Following up on his fast day-of-the-week algorithm, Ben Joffe tackles splitting an integer number of seconds in a day (0..86399) into hours, minutes, and seconds. Most standard datetime libraries take around 16 CPU cycles for this conversion because the textbook approach—dividing by 3600 to get the hour, taking the remainder, and dividing by 60 to get the minute—creates a long serial instruction dependency chain. A second family of algorithms (used in V8, Boost, and musl) computes each field independently, while Cassio Neri’s 2020 algorithm uses a single 64-bit magic multiplication and extracts minutes and seconds from the lower bits, serving as Joffe’s benchmark baseline. Joffe’s first variant (V1) breaks the serial dependency chain by computing time / 60 and time / 3600 in parallel so the CPU’s out-of-order execution engine can overlap both divisions, then derives seconds and minutes via simple multiplications and subtractions.

His V2 variant uses fixed-point arithmetic in 64 bits: multiplying time by $\lfloor 2^{32}/3600 \rfloor + 1$ puts the hour directly in the upper 32 bits and the fractional remainder of the hour in the lower 32 bits; multiplying that lower 32-bit fraction by 60 yields the minute in the upper 32 bits, and multiplying the new lower 32-bit fraction by 60 again yields the second. V3 applies the Mersenne-like modulo trick from his previous post, computing seconds via ((time + 4 * tmin) % 64) since $60 = 64 - 4$. The post also covers variants for millisecond timestamps, leap seconds, ARM NEON SIMD, and SWAR (SIMD Within A Register). On an Apple M4 Pro, V1, V2, and V3 run in 0.65x, 0.64x, and 0.60x the time of Neri’s baseline respectively—and down to 0.49x on a Ryzen 9 9950X3D with Clang—with patches already adopted in Elixir and Java’s ITU library. Because these fast fixed-point multipliers are only exact over bounded input ranges (0..86399 or slightly higher), Joffe recommends V2 as the best all-around choice for standard library implementations.

Bonus

Videos: HTTP vs HTTPS Explained

ByteByteGo’s video compares HTTP and HTTPS, explaining how HTTPS uses TLS to encrypt data in transit and authenticate the server, keeping connections between browsers and websites secure.

Images: Top 12 Agent Skills You Should Know 9 Types of API Testing Forward Proxy, Reverse Proxy, and API Gateway Explained