Rangle

The Weekly Read

A weekly, hand-picked tour through the best AI and engineering writing, grouped by the questions it is really wrestling with. Each issue tags the pieces that connect to a practice we are building at Rangle.

The Weekly Read

For about $50, a writer on Peec AI's blog published 50,000 made-up statistics and watched AI answers cite them for seven months, each citation making the numbers look more trustworthy. This week's pieces ask whether our checks are accurate enough to rely on. The Claude Code team calls "did a human read the code?" an imprecise proxy and now has a classifier set how many human approvals each change needs. Will Larson names the version where a reviewer passes agent output along unread: "meat proxy" review. At Imprint, review time more than doubled as pull requests per developer went up fourfold. DX asks whether developers' judgment keeps pace with what they approve. Our team traces how a PHP bug shelved in 2024 became a problem this month for every company whose SaaS vendors run PHP. Also here: Kent Beck on keeping the struggle, Dan Hockenmaier on which marketplaces agents threaten, and Ethan Mollick's 30 months in charts. The colored tags mark where a piece connects to something we're building.

23 worth reading · 19 newsletters · ~12 min read

The Weekly Read

"Silence is cheap to host. It can be expensive to misunderstand." Ben Yoskovitz is writing about measuring an AI product, and his point is that cheap output moves the work onto whoever has to read it. This week follows where that cost lands. At Anthropic, agent volume strained merge queues and CI until seven people built a git replacement. A low-level programmer grieves expertise that an LLM can now explain to anyone. Derek Thompson and Steven Strogatz watch AI win the craft of mathematics while interrupting the conversation that gave it meaning. Britton Russell from our team asks what a customer portal owes its visitors when some of them are agents. Also here: PostHog's lessons from 10 AI products, and a harness that only paid off on the cheap model. The colored tags mark where a piece connects to something we're building.

10 worth reading · 10 newsletters · ~5 min read

The Weekly Read

Practice has always worked better with someone watching, and there were never enough people to watch. Mike Fisher argues an AI grading against a rubric now can, for anyone. That's the thread this week: things that used to be too scarce to have. A developer who got hacked through an always-on agent comes out arguing for rewriting your own software layer rather than trusting a vendor's. Rippling replaced its BI dashboards with an agent anyone in the company can ask. A junior engineer at Criteo designs their own apprenticeship. Also here: Zotero's five-year origin, and the one part of building a developer thinks vibecoding can't give you. The colored tags mark where a piece connects to something we're building.

11 worth reading · 8 newsletters · ~6 min read

The Weekly Read

CodeScene refactored 300,000 lines of Street Fighter 3's C code in days for about $4,000, a job it puts at 12 to 18 months by hand. Anthropic merged more than 3,000 performance changes to claude.ai in two weeks. Both worked because a test or a benchmark decided what counted as correct. The argument this week is about managers. Ethan Mollick reverses his own earlier view and says most of management solves problems that people have and agents don't. Camille Fournier says AI tooling gives the managers who remain visibility in place of understanding. A survey of 308 engineering leaders finds many aren't sure what their job is any more, and Britton Russell from our team describes senior engineers who stop building to clear a review queue. Also here: Vinoo Ganesh and Hillel Wayne on what checking can't cover, and OpenAI's Dev Day. The colored tags mark where a piece connects to something we're building.

30 worth reading · 18 newsletters · ~15 min read

The Weekly Read

When AI makes generating and building fast, the bottleneck shifts somewhere else. Warp's agents turn a Slack request into a pull request in 35 minutes, and then it waits three and a half hours for a person to review it. Agents now write most of Linear's tests, so its CI became the slow part. Anthropic says that on modernization projects, the hard part becomes getting the organization to accept the changes. Maggie Appleton says a developer with two dozen agents gets faster while the team doesn't, because agreeing on what to build is still slow. Also here: why AI writing loses the reader, what an AI rollout costs engineers, and two new frontier models. The colored tags mark where a piece connects to something we're building.

24 worth reading · 9 newsletters · ~12 min read

The Weekly Read

Imagine you left a model coding alone for 35 hours. You'd expect it to get stuck or need help. Armin Ronacher tried it and got back code that passed its checks but was a mess to maintain, with magic constants hardcoded just to get past them. The problem isn't that agents can't produce output. It's that they optimize for what gets them to output, not what you'd accept. Dan Luu ran 160 trials and found the same pattern: tell an agent to use a testing technique and it calls the tool, not the judgment that makes the technique valuable. The rest of the week circles the same gap, from Gemini's product lead naming the scarce skill as "saying, precisely, what good looks like" to Ethan Mollick arguing taste is the new bottleneck. An agent will build whatever you point it at. Deciding what's worth building, and what good looks like when it's done, is still the work.

22 worth reading · 13 newsletters · ~11 min read

The Weekly Read

Three pieces this week say the code-review argument has been about the wrong thing. Review was never the quality gate that's breaking. It was carrying four jobs at once, and it beat heavyweight inspection on cost rather than on merit. Underneath that, an injection chain against Claude Code's default mode works because the model obeys its own safety rule: it refuses the attacker's decoder, writes its own, and runs that. Also here: what open models actually saved Uber, Pinterest and AT&T, Shopify reversing a successful React Native bet because building twice got cheap, and a thirty-eight-year safety engineer who wants FAA-style proficiency rules for the debugging work agents now absorb. The colored tags mark where a piece connects to something we're building.

24 worth reading · 15 newsletters · ~12 min read

The Weekly Read

Three sites published 215,128 'best software' pages written for the machines that read them, and Perplexity cites them. At the other end of the same collapse in production cost, Steve Yegge watched roughly fifty coding agents grow a body of rulings nobody designed, and Dwarkesh Patel reconstructs two incident reports in which 1,200 agents built a covert message board and escalated to taking over infrastructure. Most of this week sits between those: Ethan Mollick on which half of the job to automate, Meta's year read two ways, and Dan Luu twice. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

24 worth reading · 11 newsletters · ~12 min read

The Weekly Read

Ramp's in-house agent now writes 75% of the company's merged pull requests. Run the same feature 200 times, though, and agents keep picking the convenient data structure over the correct one, roughly one bad representation decision per eight features, with every test passing and the diff showing nothing. Both facts are the same story from opposite ends, and most of this week sits between them. Gergely Orosz, Dan Luu and our own desk all point at the same shift: the migration nobody could justify last year now has a business case. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

27 worth reading · 14 newsletters · ~14 min read

The Weekly Read

Linear published two years of data on what coding agents do to a team's throughput: teams that connected one went from 21 pull requests a week to 65, while teams without one went from 8 to 10. Nobody's review queue tripled to match, and several pieces this week ask who absorbs the difference. One argues speed stops paying past about four management layers, because each new layer adds someone rewarded for visible output. Another quotes an Anthropic engineer on team size: a project rarely holds more than two people now, since each is already running several agents. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

29 worth reading · 12 newsletters · ~15 min read

The Weekly Read

Several pieces this week explain why generic output is not the model failing. Lauren Leek derives it: under a standard loss function, personalisation is regression to the collective mean, so a vague prompt returns the average answer because that is the math working correctly. The corollary runs through the rest of the issue. Every specific you supply narrows the result, which is why taste, intent, and point of view keep turning up as the scarce input. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

20 worth reading · 10 newsletters · ~10 min read

The Weekly Read

Bruce Schneier has a one-question test for what to hand an AI: does anyone care how this got done? If not, delegate it. If the effort is the point, keep it. This week's reading is full of rules like that one. SlopCodeBench scores whether agents can extend their own code across eight checkpoints without breaking earlier work, and top models manage about a third of the time. And Rachel Laycock explains why the conductor keeps a job even when every musician is excellent: someone has to hold the whole system in their head. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

21 worth reading · 10 newsletters · ~11 min read

The Weekly Read

Three pieces this week put hard numbers on things we usually argue by feel. Refactoring cut an agent's input tokens by 83%. DoorDash halved its per-turn token bill with one harness change. And a team whose pull requests grew 3.5x with AI worked out why it was catching fewer bugs: the PRs got too big to review well. Alongside those, Noah Smith asks what more intelligence actually buys us, and Anthropic deleted 80% of its own system prompt. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

30 worth reading · 12 newsletters · ~15 min read

The Weekly Read

The scarcity question got personal this week. For two months the answer to 'what survives when execution is free' has been market-shaped: trust, taste, verification, specs. This week it comes back as judgment, attention, making, character, and rest, none of which anyone can hold on your behalf. Ronacher names the trap: people who fear being replaced respond by handing machines more of their judgment. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

30 worth reading · 14 newsletters · ~15 min read

The Weekly Read

This week's pieces keep arriving at the same claim from different directions: as AI pushes the cost of writing code toward zero, the durable work moves upstream into understanding, verification, and specification. Ronacher's Tower of Babel essay is the capstone; Bun's 11-day, $165K Rust rewrite is the price tag. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

25 worth reading · 12 newsletters · ~13 min read

The Weekly Read

The week clustered hard on a single claim, argued from four directions: when generation gets cheap, the irreducible human job is understanding and taste. Geoffrey Litt names the failure mode directly (cognitive debt, the comprehension you skip when you ship code you don't understand), Claire Vo finds her taste-based model rankings landing almost exactly opposite the LLM-judge leaderboard, the Pragmatic Engineer's hiring managers say they would sooner bet on judgment than on an elaborate agent setup, and a 5,920-person survey catches the workforce splitting on exactly this line. Around that core: what agent observability does to how we read code, where value pools when creation costs collapse, and a cross-domain detour into oral epic and the craft that resists being written down at all. One of this week's picks comes from our own desk: Ben on how the developer job got bigger once the well-scoped task became the first thing you hand to an agent. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

13 worth reading · 11 newsletters · ~7 min read

The Weekly Read

Another convergent week, and the same claim keeps surfacing: once execution gets cheap, value pools in judgment, taste, and the decision about what is worth making at all. The sharpest thread this time is the planning artifact turning inside out, where teams build the prototype first and write the document it earned (Vogels on Amazon's inverted Working Backwards, Gusto shipping a product line in ten weeks with the PR standing in for the PRD). Elsewhere: what AI does to how we think, where human comprehension still earns its keep, and why sounding competent and being competent have quietly come apart. Skim the headers, dive where you are curious, and watch for the Rangle Practice tags that connect a piece to something we are building.

21 worth reading · 10 newsletters · ~11 min read

The Weekly Read

We made writing cheap; understanding stayed exactly as expensive. This was the most convergent week of the run, with nearly every piece circling one claim: once code is near-free, value pools in deciding what to build and being able to tell whether it's right. Two of this week's picks come from our own desk: Britton on the surprising data about who's best at vibe coding, and Ben on rebuilding rangle.io for agentic search. Skim the headers, dive where you're curious, and watch for the Rangle Practice tags that connect a piece to something we're building.

35 worth reading · 12 newsletters · ~18 min read

The Weekly Read

We made writing cheap; understanding stayed exactly as expensive. This week's pieces trace where the value pools once code is near-free: review you can trust, evals that encode judgment, and the capability-transmission pipeline AI quietly erodes. Skim the headers, dive where you're curious, and watch for the Rangle Practice tags (Reviewing AI Code, Evals as the Moat, Task Design, Leverage over Output) that connect a piece to something we're building.

25 worth reading · 11 newsletters · ~13 min read

The Weekly Read

The week intentionality became the bottleneck: as a frontier agentic model absorbs the hundreds of small choices you used to make, the human role shifts from steering to commissioning, even as researchers put a hard number on the productivity ceiling. Skim the headers, dive where you're curious, and watch for the Rangle Practice tags (Engineer Role, Task Design, Leverage, Evals) that connect a piece to something we're building.

26 worth reading · 11 newsletters · ~13 min read