What we're reading this week

Rossi's heuristic is "outsource the knowledge, protect the reasoning," and the question in the pull quote is the version you can ask yourself with the tab already open. The practice underneath it is concrete: write your own draft first, then have the model rebuild it without showing it yours, so the differences between the two are information about what you left out rather than a polish of what you wrote.

Asks what happens when the person using the AI no longer holds a mental model of the system it builds, and argues agentic development hides the cost and quality trade-off rather than removing it. Grounded in the SWEBOK error/defect/failure taxonomy and a caching-layer scenario specific enough to check against your own codebase.

Behind the hype title is a method you can run this week. Build the design doc with a long-context session, then open a fresh zero-memory session that receives only the doc and has to reconstruct the system from it. Wherever the second one builds something else, the doc has a hole. The warts are in there too: sycophancy loops, and mistakes that get mass-produced once they are in the context.

Reframes AI-assisted cheating as an incentive-design problem. Enforcement (in-class essays, oral exams) fails, and the lever that works is cultivating moral identity so the motivation itself changes. Paywalled past the opening argument, which is still where the reframe lands.

AI made the surface layer (screens, UI, code) nearly free, so the durable human work is defining the domain's ontology: what exists, what it means, how things relate. The boarding pass and the SABRE Passenger Name Record carry the case at length, and the argument is the best-built one in the issue.

An empirical census over 461K pull requests and 595 days, surfacing the tokens that spike in Claude-authored PRs. What comes out is a verification vocabulary: load-bearing, mutation-tested, byte-identical, re-derived. The page is mostly the interactive dataset rather than prose, so treat it as something to poke at instead of something to read.

Running the same feature 200 times per variant shows agents defaulting to the convenient data structure over the correct one: boolean flags that can represent a seat both held and sold, parallel arrays acting as a second source of truth, all tests green. One bad representation decision per eight features compounds fast. Reading the diff cannot catch any of it, because each change is correct against the structure it was handed, and reading the representation can.

Reframes "AI gone rogue" as an engineering choice: the gap between plausible and normative output, running inside an unsupervised Ask/Act/Report loop. It complicates the doomer consensus without joining the other camp, though the AI-lab economics angle stays at commentary.

From our own desk: across healthcare, financial services, insurance and the public sector, the AI roadmap stalls at the same wall, which is a managed-service stack that cannot host the operational layer agentic workflows need. Two things changed the arithmetic. The business already committed to the capability, so replatforming moved from cost center to prerequisite, and agent-assisted migration removed the manual labor that used to make the work undeliverable. Read it beside Ramp below: both land on owning the layer everyone else rents.

A 5.5-person team whose product is the agent the rest of engineering codes through, now authoring 75% of merged pull requests. The pull quote is the end state they were paid to produce, not the starting condition: what it replaced was an agent that could not reach internal services and held none of the company's context. Their read is that owning that context is the moat and model quality is not, which inverts buy-don't-build for this one category.

Takes apart the OpenAI case study framing Asana's Enzyme migration as $5.9M saved, talks to Asana's dev-productivity lead, and sets it beside Airbnb, Uber's 600K tests and Bun's Zig-to-Rust port. The dollar figure is the least interesting output. Every team carries a list of work it declined on cost and never revisited, and that list is now wrong in one direction only.

The Stratification section is the part to read: AI multiplies the leverage of full-lifecycle systems thinkers, and professional managers become the bottleneck. Grounded in named anecdotes rather than leadership platitudes, which is what keeps it from reading as a flattering story about engineers.

Offensive AI agents carry positive expected value, and defenders, who need above all not to break things, carry negative. The same asymmetry explains why AI-native startups beat risk-averse incumbents holding identical tools, which makes it a structural argument rather than another round of startups-are-faster.

Inference dropping to roughly $0.10 a task is what finally makes consumer and business AI apps viable. The frame is frontier "IQ 180" work against cheap "token spewer" work, which is a more useful split than another round of model-release scoring, and it is the economic argument under any tiered model-selection policy.

A dogfooded case study of making the autonomy slider dynamic: score every run for risk and confidence, then route red to a human ticket, yellow to a Slack question with the context attached, green straight to a pull request. The pull quote names what a fixed setting produces in both directions at once, which is the reason to route the judgment rather than hold it.

Muratori keeps AI out of his game because the programming is the point, not the output. Alongside that: understanding the machine from first principles (read the assembly, know the three pillars of CPUs, optimize toward theoretical limits rather than local profiler minima), and a historical parallel worth sitting with, where engine licensing was the games industry's AI moment, flooded the market, and killed organic discovery.

A security researcher's retrospective on the realizations that reshaped how he reasons about incentives and causality. A mind visibly changing itself, and it extends "knowing how things work" from debugging outward to everything else.

LLM agents collapse the cost of performance work by orders of magnitude, which makes workload-specific optimizations that were never worth the time (native regex compilers, custom JITs) newly worthwhile. Backed by his own ripgrep and benchmark numbers, and he flags the writeup as one of his quick, non-rigorous ones.

Reframes remove-versus-schedule as an organizational and coordination problem: Brooks' communication costs, and a commons degraded by feature teams each acting reasonably. Scheduling is brittle overfitting that only pays for teams already disciplined enough not to need it.

A trained economist abandons a long-held frame, that America's malaise is material, and marshals the evidence that the real drivers are positional goods (status, belonging, respect) no market can supply. Worth reading for the writer changing his mind as much as for the argument he changes it to.

A solo B2B founder's operating system for running 10 to 15 cloud agents: P0/P1/P2 triage folders, named playbooks like Watchdog and Land-PR, a narrated-video verification gate before anything lands. The counterweight is the honest part, since product-market fit and priorities still come from talking to one lawyer and working off a handwritten list.

An orchestrator plus executor subagents across Grafana, PagerDuty and GitHub, a lessons file the agent appends to itself, and an open-source on-call kit to copy. Honest about how many taste-driven iterations the human-facing status report needed, and every change still keeps a named human owner.

A structural account of how decisions actually move through a team's invisible backchannels, and who quietly ends up outside them. The mechanism is real and transferable, which is what separates it from the usual career advice.

Restructures each stage of the SDLC around a committed-artifact chain: intent to spec to plan to diff to review findings to incident record. Every hop has to be readable by a person and actionable by a machine, and the chain of commits doubles as the audit trail. When build stops being the bottleneck, human attention concentrates at the gates between the hops.

Transplants James C. Scott's legibility and metis onto engineering dashboards and metrics: how a metric compresses the context away, how measurement reshapes what leaders attend to, and what tacit knowledge dies once the mess gets standardized.

The spine is how the shape of a representation constrains what an agent can safely build: data contracts as code, a domain and semantic and capability context layer, reversibility classes. Trust is the moat, and there is a number behind it, since a semantic layer moved text-to-SQL accuracy from about 20% to 92.5% on the same model.

Eighteen terse propositions on how complex systems actually behave and fail. Archetypal enough that most of what people assume about resilience traces back here, usually second-hand, which is a good reason to read the source once.