What we're reading this week

A sharp reframe: an agent's long-term capability is bounded by the quality of its feedback loops, not the raw model. The twist, system software with clear specs gets easy; squishy-feedback SaaS UIs get hard.

A living, bookmark-worthy index of coding-agent patterns: "hoard things you know how to do," the compound-engineering loop, specialist subagents, red/green TDD, agentic manual testing. The external cousin of our own technique map.

An Anthropic eng lead walks through three concrete workflows (a 3D floor planner built from email receipts, live dashboards, a $20 physical Claude buddy), all anchored to one move: "go one abstraction layer up" when the work turns tedious.

Across three datasets (including 18k ICLR peer reviews), LLMs introduce bigger meaning-shifts than human edits even when asked only to fix grammar, and push writing toward a flat neutrality. The "paradox of preferences": people stay satisfied while reporting a loss of their own voice.

Programming-book sales are down sharply, but the real point is what the format used to force: slow, by-hand retyping. The thesis isn't nostalgia, it's that the typing was the practice.

Running Claude Code as a programmable agent, not fancy autocomplete: persistent memory, custom commands, parallel sessions, and treating plan mode like a design doc a second Claude reviews.

Two reusable patterns: the "combine harvester" (one markdown file holding instructions, progress, and next steps so an agent can pause and resume across days) and overnight "guards" (daily procedures that catch judgment calls CI can't gate).

A working designer's real AI workflow: write-to-think on paper first, generate janky HTML prototypes to explore, dispatch subagents to stress-test, and keep a "Watchtower" of decision context that compounds across projects.

How to use linters and static analysis as "sensors" that feed coding agents. Internal quality becomes the variable that decides whether an agent can do useful work: a tangled codebase tangles the agent too.

Uses the multi-armed-bandit problem as a model for explore/exploit choices in life and work, then turns it into a personal case for narrowing focus. Strong cross-domain piece on how focus compounds nonlinearly.

Names the change cleanly: org charts had a fat middle layer of translators (spec-to-ticket, ticket-to-PR, PR-to-status), and that's the layer AI ate. What survives is judgment-heavy, harness-designing, contribution-not-coordination work. One of the sharpest pieces on why "manager" as a title is at risk.

Holds three ideas at once: some math helps every programmer, most fields don't pay off for the average one, and every programmer has at least one branch that would help them, which they can't find without broad exposure first. A case for breadth as the prerequisite to choosing depth.

The founder of a fast-growing AI harness stays refreshingly skeptical: AI mutes the guilt of writing hacks (so tech debt piles up), motivated devs are drowning in slop PRs, and old enterprise patterns (DDD) return because agents behave like junior engineers.

Beck treats LLM calls as a new primitive: requires/ensures blocks written in structured English, subagents passing file pointers instead of data, and a shift from imperative steps to declared outcomes.

Why a $2T valuation could pencil out: agentic inference will be the largest compute market by far, with very different needs (capacity over speed, latency tolerance) than today's GPUs. The "rack-in-space" framing is the next unbundling of compute.

Tracks April 2026's pricing inflection: both labs ended discounted enterprise plans and now charge near API rates. Coding agents are the PMF moment because power users burn enormous token volumes (Willison estimates $2,180/month of value on a $200 plan).

A short, useful observation: programming-language choice used to be lock-in and increasingly isn't, because agents can port codebases cheaply. Changes how to think about tech-stack risk (and pairs nicely with "use boring languages" above).

Uses Toto, the keiretsu, and conglomerate structure to ask why "focus on one thing" is a Western default rather than a universal law of company design. Structural analysis that complicates the specialization consensus.

A practitioner who once wrote "the diminished art of coding" updates in public: the same LLM that ships barely-passable PRs fast can write higher-quality code slowly. Which one you do is the engineer's choice, not the tool's.

A 2008 essay that lands hard now: elite education trains hoop-jumping and risk-aversion at the cost of independent thought and the courage to pursue "unscalable" callings. A good test of what becomes scarce when achievement-chasing is universal.

Three meeting archetypes (the promotion conversation, the build-with-us meeting, the shared-fate meeting) and the core senior skill of intuiting what someone needs before they say it. Makes the case for instinct as compressed experience, not guessing.

A founder shares the actual artifacts: offer letters with a personal preamble on heavy paper, a live append-only priority doc, Friday hackathons with one-week turnaround, board decks shared with the whole team three days early. The "systems that encode care without going formulaic" pattern, and honest about what didn't work.

Concrete tactics for setting the emotional temperature of a room instead of just mirroring it: softly naming what's happening, the "what I learned / what I'll do" template, pacing nods, offering a break. Repeatable without feeling scripted.

The clearest account yet of agent orchestration as designing a membrane with four levers: the workspace (the real prompt the agent reads), drift, verifier visibility (a Goodhart trap), and blast-radius vs. recovery budget. Sponsored, but unusually substantive. This is the third strong "harness" piece in three weeks, so we're pulling it together into a Rangle practice.

Reframes Architecture Decision Records as the lever for reviewing AI work: instead of inspecting every line, review a short record of the choice, the alternatives, and the consequences. Turns judgment into a reviewable artifact (and feeds the next agent's decisions too).

The altitude of a question (wide vs. deep, platform vs. point) decides whether a meeting can do useful work. "Wide or deep" is seductive because everyone gets to sound smart, but the real question is always one level down.

Rather than reconstructing context months later, capture research synthesis, design moves that landed, and the prompts that worked, so each project makes the next one cheaper to think through. Treats documentation as a portable second brain, not process hygiene.

How a "check with Mike" habit turns from due diligence into architecture: past correctness keeps subsidizing present authority, a silent veto forms, and everyone else's judgment muscles atrophy. The non-obvious fix: don't route around the person, route through them while extracting the rules so the next decision can travel without them.

Real numbers at scale: 80 prod deploys/month/engineer, 60%+ AI-written code, under 1% change-failure rate. The core mechanism is forced-AI-by-default to surface failures in public, because teams won't learn how AI works by waiting for the perfect use case.