A living atlas of one-screen explanations.

A model alone is a curious oracle. A model in a harness is a worker. The interesting craft of 2025–2026 has been less about better models and more about the satellites: context shaping what the model knows, tools shaping what it can do, verifiers closing the loop on whether it succeeded. The dashed line is the most important — most agents that fail in production fail there.

From the browser's point of view, a static site loads "instantly." Almost all the work — DNS lookup, TLS, edge routing — happens before the bytes even start. Once Cloudflare's edge has matched the host to a Pages project, the rest is internal traffic between Cloudflare's own services. The closer the user is to a Cloudflare PoP, the more this whole diagram collapses into "just a few milliseconds."

Vanilla OAuth 2.0 worried about server-to-server secrets. PKCE (pronounced "pixy") was added because mobile and SPA apps can't keep a secret. The trick: the client invents a random verifier, sends only its SHA-256 hash to the auth server up front, and reveals the verifier itself only when redeeming the code. Even if an attacker intercepts the authorization code, they don't have the original verifier and can't redeem it.

A Merkle tree hashes data in pairs, all the way up to a single root hash that fingerprints the entire set. The quiet magic is the proof: to convince someone that block C belongs, you don't hand over the whole set — you hand over your block plus the handful of sibling hashes along the path to the root (here just H(D) and H(AB)). They recompute the root and check it matches. This is what lets Git, Bitcoin, and Certificate Transparency verify membership in enormous sets with a logarithmic-sized proof — a perfect diagram subject because the whole idea is a shape: a path climbing a tree.

In modular hashing, a key's server is determined by hash(key) mod N — clean until N changes and every assignment shuffles. Consistent hashing fixes this by projecting both keys and servers onto a shared circular hash space. A key's owner is whichever server appears first clockwise from the key's position. When a server joins or leaves, only the keys in that server's arc of the ring need to migrate — roughly K/N out of K total, the rest stay put. That bounded migration cost is why Redis Cluster, Cassandra, DynamoDB, and most CDN routing tables use it: the cluster can reshape itself without emptying and refilling every shard.

A database index stores a copy of the table's key column in a balanced tree whose nodes are fixed-size disk pages. At each level the engine compares the search key against the stored key separators and follows exactly one pointer downward. A table of 100 million rows — scanned sequentially, half a million pages — takes the same three or four reads as one with a thousand. The diagram subject is a good one because the tree shape and the highlighted path together convey the O(log n) guarantee in a single glance; no amount of text conveys it as fast.

A Bloom filter answers "have I seen this before?" using a fixed-size bit array instead of storing every item. Inserting a key runs it through k independent hash functions and flips the bit at each resulting position to 1; checking a key does the same lookup and reports "definitely not present" if any of those bits is still 0, or "maybe present" if all of them are 1. The catch is exactly that "maybe": the diagram earns its place because carol and dave run through the identical procedure but land on opposite verdicts — one miss is enough to prove absence, but a lucky collision of unrelated inserts can fake presence, which is the one tradeoff that defines the whole structure.