What we're reading this week

A retrospective built around one deliberately inefficient habit: read the agent's output, then type it in again by hand rather than accepting the diff. The reported payoff is not comprehension in the abstract but a spatial map of the codebase, the sense of where things are that sends you to the right file weeks later.

A short, provocative argument that relaying AI output verbatim adds no value: you have to read it, understand it, validate it, and rewrite it in your own words. The sharpest turn is the inversion of code review, where the reviewers ended up doing the implementation and nobody actually wrote the thing.

Diagnoses how the news's selection mechanism, which reports only the controversial frontier, quietly distorts what we think a field knows. It complicates rather than confirms the 'psychology is mostly garbage' consensus.

Built on more than twenty practitioner interviews, it maps Terence Tao's split between solving a problem and understanding it onto the question of what stays scarce once execution goes to zero.

A GitHub engineer argues that domain expertise, not prompt-craft, is what lets you steer a model hard. The information is already in there; getting it out is the part that needs someone who knows what good looks like.

A working method for surviving model deprecation: diff a candidate model against your production model on your own cases instead of scoring it in the abstract, and keep the 'good enough' threshold as a dial you can drag rather than a constant in the code. Agreement between the two carries no information, so the disagreement set is the whole decision surface.

Nikhyl Singhal synthesizes the CPOs of Midjourney, Laurel, and Mutiny, all running small teams on purpose. Three claims worth arguing with: the backlog has stopped being maintained at all, shipping rights follow understanding rather than title, and the product org turns inside out.

A structural history of why the PC, email, and the smartphone turned time savings into higher expectations rather than slack, through the autonomy paradox. Then it uses the desktop-publishing quality boom as the case for value concentrating in taste when creation gets cheap.

Molly Graham offers 'emergence' as an alternative to destination-driven career planning: follow energy and principles rather than a plan. A biology-to-career frame that complicates the standard twenty-year-plan advice.

Under a minute, and it reframes writing as a way of building rather than a way of producing output. Worth the sixty seconds for the closing line alone.

A designer at FitXR documents the concrete workflows that let one person own six projects end to end: Claude Skills and MCPs wiring Slack, Granola, and Linear together for drift detection, raw data dumps turned into source-of-truth docs, and prototyping branching behavior in Cursor rather than screens. Real builds, warts and all.

Uses a trivial logistics event, moving someone's desk, to teach a genuinely structural model: amygdala hijack plus Paloma Medina's BICEPS core needs. It generalizes to reading and defusing any surprising emotional reaction, and it comes with concrete managerial moves rather than sympathy.

Why well-meaning managers overpromise (optimism does not feel like lying, and there is real pressure to hold onto a distressed high performer) and the asymmetric happiness math that makes it backfire. Comes with concrete rewrites.

Goes past the usual 'keep hiring juniors' take by reframing the debate structurally: the junior question is a symptom of a waterfall production-line org. Backed by a practitioner retrospective and one sharp inversion, that in a fast-changing industry experience is the depreciating asset.

A rebuttal to the self-documenting-code orthodoxy that moves the argument from readability to transmission. Code records only what you told the machine to do, so it cannot certify that those instructions were the intent. Anything only a human can supply has no other channel and has to be written down.

A named practitioner documents a real agentic dev topology, warts and all: a disposable Linux VM plus Tailscale so approvals stop being necessary, a per-worktree secure dev-URL wrapper, chezmoi for dotfile sync, and a candid ChatGPT versus Claude comparison. The techniques are specific enough to copy.

Simon Willison walks through MCP 2.0's stateless spec change and argues why MCP is a safer, more auditable way to hand an agent tools than terminal plus curl access. The case is about what you can reason about afterwards, not about convenience.

A mechanics-first walkthrough that upgrades a naive LLM loop into a plan-act-recover system, explicitly without hiding behind a framework: typed tools, plan-as-DAG parallelism, tiered memory under a retrieval budget, cheap checks before expensive ones, four-way error classification. Every primitive is a named failure with a countermeasure attached, which makes the list testable against a harness you already run.