Weekly Review — July 27-August 2, 2026

TL;DR: Three posts about where the human stays in charge as agents do more of the work. “Laws & Disorder” closes with Tesler’s Law: you can’t delete a system’s complexity, only choose who owns each piece — and AI changes that math. Generate-and-Verify reads test-time compute, verifiers, and agent loops through the P-vs-NP asymmetry: hard to find, cheap to check, so spend compute on the search and let a cheap checker confirm. And Understanding Is the New Bottleneck argues that when agents write the code, keeping up with what they wrote is the real constraint — with a Kiro skill I built that explains its own diffs and quizzes me before I ship.

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

Tesler’s Law: You Can’t Delete Complexity, Only Choose Who Owns It

Tesler’s Law, the conservation of complexity, is a design heuristic: for a given problem scope, some complexity is inherent — it can be reallocated between owners but not deleted. The useful move is to split the number most people conflate: the total complexity of the whole system, and the complexity you personally have to manage and operate. A well-run managed service shrinks what you manage, which is a genuine win; AI now makes it cheap — in build effort — to create a focused component with the features you need, and a narrower scope carries less inherent complexity, which can lower the total. But you own and operate it, so what you manage goes up. Buy less to manage, build with AI for less total but you hold the pager. Third and final in “Laws & Disorder.”

Generate-and-Verify: What P vs NP Teaches Us About AI Reasoning

The defining feature of the complexity class NP is that a candidate answer is cheap to check — even for its hardest problems, where no efficient way to find one is known — and that same asymmetry explains a lot of how modern AI reasoning works. Test-time compute spends more effort on the search, a verifier or reward model or unit test plays the cheap checker, and an agent loop is just propose-then-verify repeated. In compute-matched tests, a small reliable verifier gating a strong generator can beat scaling the generator alone — but the trick only pays when a cheap, trustworthy checker exists, a verifier that confidently accepts bad answers can be worse than none, and none of this means a model “solves” NP-hard problems. It searches, and lets a cheap check do the confirming.

Understanding Is the New Bottleneck

When agents write the code, the hard part is no longer writing it — it is understanding what the agent wrote well enough to keep steering. Geoffrey Litt’s framing is that the human job shifts from verifying correctness — which, in his telling, agents increasingly handle themselves via tests and checks — to understanding so you can participate and have the next idea; skip it long enough and you accrue “cognitive debt.” His fix borrows from teaching: have the agent write an explainer for its own change and quiz you on it before you ship. I ported his ExplainDiff idea to a Kiro CLI skill and ran it on a real diff — it produced a self-contained explainer with a five-question quiz, and the rule that comes with it is a good one: don’t send a PR you can’t pass the quiz on. The code is on GitHub.

The Thread This Week

Read together, the week is about where the human stays in charge as agents take on more. Tesler’s Law says you can’t delete complexity, only decide who owns it — a judgment call, not a technical one. Generate-and-verify says the durable human asset is the checker: own a cheap, trustworthy verifier and let the model search. And “understanding is the new bottleneck” says the role worth protecting is comprehension, because that’s what lets you have the next idea. Judgment, ownership, understanding — the parts that concentrate rather than shrink.

Until Next Sunday

That’s the week, and the close of “Laws & Disorder”: a law that informs build-vs-buy by asking who owns the complexity, an NP asymmetry that tells you to spend on the search and cheap-check the result, and a reminder that understanding, not writing, is now the thing to protect. The thread is the human role concentrating toward judgment, ownership, and comprehension. Which of those three are you actively defending in your own work?