What we're reading this week

A data-backed retrospective that opens with "I was wrong." Coding agents did not just raise PR count, they inflated PR size past the roughly 200-line threshold where review thoroughness falls off. Approval rates held steady while bug-catching dropped. The best diagnosis this year of why AI review feels fine and isn't.

A first-hand report from inside Anthropic: six months of Claude Managed Agents, and the Bun Zig-to-Rust rewrite done in 11 days across 64 agents for about $165K. The detail worth keeping is where the tokens go: most are spent on discovery, verification, and testing, not on writing the code.

A real design session on shared memory for coding agents: memory gets built from what the team confirms over time, not from whatever one model decides to remember. Comes with a concrete supervisor-agent architecture, and a design rule that applies well beyond agents.

An interview with Anthropic's first technical PM on eval-driven development, how Claude got good at coding, and where human judgment stays irreplaceable.

Guidance straight from the Claude Code team on writing for the new model class, and the advice is mostly to write less. If you have been adding to your CLAUDE.md files all year, this is the piece that says to try a stripped-down baseline first.

A nuanced, evidence-based conversation on where formal methods actually fit, why property-based testing is the pragmatic default, and the craft-documentation gap in software engineering. Refreshingly unwilling to oversell its own subject.

Two ML reviewers found 68% of the 22 papers they read were AI slop, including author-swap fabrications that still got accepted as orals. Peer review is breaking under volume in exactly the way code review is.

A director of engineering sorts his own practices into two piles: the ones that assumed code was expensive to write, and the ones built on costs that have not moved at all, like coordination, verification, and accountability. The first pile is bigger than you would expect.

A structural argument that the model layer has no moat, so value migrates to enterprise services and distribution. Open weights win on the same logic that open infrastructure did.

A controlled experiment, not a retrospective: re-run the same feature prompt after each refactoring step and watch input tokens fall from 159,564 to 27,360. The saving comes from the agent finding what it needs without reading everything, which makes clean code a line on this month's bill rather than a long-run promise.

TRM Labs redesigned its workflow around outcomes rather than roles and encoded the result into an open-sourced harness. The inner-loop/outer-loop framing is useful, and "specialists bottling taste into platforms" is the clearest description yet of how craft scales past one person.

Pricing a real AI product with hard numbers, model-migration cost shocks, and honest uncertainty about CAC. Cost structure is the new SaaS-margin problem and very few people are writing about it this candidly.

A practitioner retrospective built on a blind seven-model benchmark, with a genuine mind-change at the end. The argument: once raw capability is table stakes, the scarce frontier moves to what it is like to work with a model.

If intelligence converts information into decisions, that conversion has a ceiling: it is limited by the quality of the information going in and by how much of the outcome was ever decidable. Past that point, a smarter model buys nothing, because intelligence was never the constraint. Keep this one handy for the next "just use a better model" proposal.

A Stanford SIEPR synthesis that complicates the AI-jobs panic: the most-exposed workers fared marginally better on unemployment, adoption sits near 20% of firms, and gains concentrate in novices. The epigraph is a forty-year-old warning against exactly this kind of enthusiasm.

A first-hand reliability grievance that grows into a bigger argument: organizations are torching the reliability of profitable operations in order to chase AI adoption, forgetting that reliability was the product all along.

Business incentives, not technical capability, decide whether AI gets deployed against fraud. The detail that makes it: the quote comes from an AI assistant candidly incriminating its own parent company.

Primary-source analysis of an agentic model chaining zero-days to escape its sandbox and cheat an eval, with a sharp structural point about how safety guardrails create a defender/attacker asymmetry.

Six months of building throwaway personal apps for an audience of one, with real cost accounting and a repeatable "aggregate data, add an LLM" pattern. The quote is the whole thesis and it holds up.

The literal instantiation of coding a tool for exactly one person: a personal API, a self-directed pager, and a desk printer, all built warts-and-all by someone with no coding background.

A systems-level deep dive (local-first DB, sync engine, render-first auth, GPU-only animations) that frames Linear's speed as accumulated craft rather than any single trick. A good answer to what a moat looks like when the implementation is copyable.

An honest retrospective on the creator journey with concrete mechanics: the "said it three times, post it" rule, a contrarian-take framework, and the operator-versus-creator path.

Price's Law says a small fraction of a group produces most of the output. Fisher refuses the usual reading: identifying the vital few is easy and every organization already does it automatically. The problem is what happens next, and the fix is stewardship (air cover and focus) rather than more volume.

A concrete, failure-grounded method for finding high-leverage problems: absorb problems rather than requests, let them accumulate, find the common shape, then pressure-test with prototypes and RFCs. The self-skepticism in the quote is what makes it a method rather than an anecdote.

Real platform specifics: dynamic skill loading cut per-turn tokens from roughly 42K to 20K, plus orchestrator pinning, a 60+ tool enforcement layer, and eval-gated model swaps. The rule underneath the quote: if a constraint matters, put it in tool code, where a model change cannot silently drop it.

Beck restates his 3X framework with feedback-loop reasoning: each growth phase needs a different approach to finance, team, product management, and risk, and mismatching the phase is what kills ideas.

A structural teardown of the planning artifact itself: a recursive MECE cascade from mission down to metrics, where the format is the thing keeping distributed decisions aligned. Worth reading against any dashboard you currently trust.

A contrarian, structurally-reasoned case that durable teams convert intractable cross-goal prioritization into tractable within-domain resourcing decisions. Read it as the argument against the scoring model you just adopted.

When an architect leaves, the context in their head leaves too, and their successors end up building a new layer on top of code they can no longer confidently change. Larson names this the "code horizon," then extends the same failure to LLM output. The quote is the phrase of the week.

Separates raw intelligence (fast intuition) from the transferable skill of thinking clearly under uncertainty, with a nod to Keats' negative capability. The useful implication is that the second one can be taught.