Weekly Review — July 20-26, 2026

TL;DR: Three posts about the cost you can’t see until you go looking. “Laws & Disorder” continues with Hyrum’s Law: every observable behavior of your API is a contract someone depends on, and AI agents that route around your breaking changes don’t repeal that — they turn a loud, fixable failure into a soft, recurring tax. The Quadratic Wall reads the long-context architecture race as one algorithms story: attention is O(n²), and the honest question is which cost axis each technique actually moves. And instead of trusting a generic leaderboard, I benchmarked coding agents on my own tasks — where the priciest model lost to a mid-priced one, and the tool winner flipped with the rate I pay.

This is the Weekly Review, a Sunday digest of everything that went up on the blog this week, plus a short list of things I read but didn’t write about. If you only have ten minutes on a Sunday, this is the one to read.

Prefer to watch? This narrated walkthrough covers the whole digest in a couple of minutes.

This Week on the Blog

Hyrum’s Law: Who Pays for a Broken API in the Age of Agents?

Hyrum’s Law says that with enough users, every observable behavior of your API becomes something someone depends on — documented or not, the implementation quietly becomes the interface. The 2026 wrinkle is that APIs are increasingly consumed by AI agents through layers like MCP, and an agent with the right tool permissions and error feedback can dynamically route around a breaking change by writing its own glue, so the user may never notice the break. But that flexibility is not free: unless the glue is persisted and reused, the agent regenerates the workaround per call, so you pay in latency and spend, and each bespoke patch can vary between generations in a way a pinned, versioned library doesn’t. Agents trade a loud, fixable failure for a soft, recurring tax — which is why API discipline matters more now, not less. Second in “Laws & Disorder.”

The Quadratic Wall: Beating O(n²) Attention

Standard self-attention costs on the order of n² in the sequence length (holding model width fixed), in both arithmetic and the attention-score memory it materializes, and headline after long-context headline of the last few years has been an attempt to beat that wall. The honest way to read them is by which cost axis each one moves: FlashAttention keeps exact O(n²) arithmetic but cuts materialized memory from O(n²) to O(n); linear attention and state-space models like Mamba lower the arithmetic exponent itself, while sparse attention prunes which pairs get computed — near-linear for some patterns, only a constant-factor saving for others. Those axes don’t move together, so no single technique simply wins — and the oldest takeaway still holds: the cheapest quadratic is the one you never trigger, so context discipline and retrieval can beat brute-forcing a longer prompt on compute cost.

Stop Guessing Which Coding Agent to Use — Benchmark It

Generic coding-agent leaderboards don’t tell you which model, wrapped in which CLI, does your kind of work at a price you’re happy to pay, so I built a small task set mirroring my real work and ran an open-source framework that measures cost, quality, and latency together. Two findings surprised me: the priciest model (Opus 4.8) missed a task that a mid-priced one (Sonnet 4.6) passed at a third of the cost, and when comparing the same model across two tools, the per-credit rate you actually pay can flip which tool looks cheaper. All numbers are from real runs I did on my own tasks.

The Thread This Week

All three posts refuse the surface answer and count the real cost. Hyrum’s Law is about the contract you didn’t write but still pay for — now paid per call by an agent’s silent workaround. The Quadratic Wall is about the exponent hiding inside “just put the whole document in the prompt.” And the coding-agent benchmark is about the leaderboard that was never measured on your workload. In each case the move is the same: look past the headline and measure the thing that actually bills you.

Until Next Sunday

That’s the week: a law that explains why your “non-breaking” change broke someone, an algorithms race to bend attention’s quadratic, and a benchmark that beats a generic leaderboard for your own decisions because it runs on your own work. The thread is refusing the surface answer and counting the cost that actually shows up on the bill. What’s a cost in your own stack you’ve been assuming instead of measuring?