Tap Notes: Friction Was Load-Bearing

Two Armin Ronacher essays anchor today’s reading, and they make the same quiet point from different angles. The slow parts of building software (arguing in review, waiting on the team that owns the storage layer, getting stuck and asking for help) weren’t waste. They were how people stayed synchronized and how work got stopped. Agents remove them, and nothing announces what went missing. The rest of the list covers what that costs, what the models cost, and what to do about it.

Loops and the missing brake

The Coming Loop (June 2026) Armin Ronacher looks at the “harness loop”: work gets queued, agents attempt it, and an outer loop judges whether to keep going. He argues it suits mechanical jobs like porting, performance exploration, and security scanning. For lasting systems it produces defensive, poorly architected code, and he says you can’t opt out, because attackers and competitors will loop regardless.

Why it matters: The sharpest part is how the rot happens. Each iteration’s judge sees only the local delta, so every change looks defensible and the architecture degrades anyway. His working categories (porting, perf search, scanning) are the ones with an external ground truth, a test suite or a binary signal. Read it as a rule: loop the verifiable and the disposable, and keep a human on anything that needs invariants. The dependency risk is the sleeper. A codebase that assumes machine participation in its upkeep is exposed to cost shocks and lost access, and nobody is pricing that in.

The Tower Keeps Rising (July 2026) Ronacher’s argument: coordination, not code production, is the real constraint on large software projects. Working through other people kept the team’s shared mental model in sync, and agents let each person route around that.

Why it matters: At Babel, losing the common language stopped construction. With agents, construction continues after the shared model is gone, so there’s no failure signal. Tests pass, explanations generate on demand, and nobody ever had to converge. The uncomfortable follow-up is that any replacement for the lost friction (decision records, mandatory cross-boundary review) can be skipped, and skipping it is the productivity win. One idea worth trying: have agents produce a human-reviewable account of which invariants a cross-boundary change touched.

Local Qwen isn’t a worse Opus, it’s a different tool (June 2026) Alex Ellis put local Qwen models on a roughly $12,000 workstation GPU for his small software business. The hardware paid for itself through specific wins, such as spotting a customer underpaying for more than a year. He still can’t leave the models unsupervised on long-horizon work.

Why it matters: The failure he describes is the one to remember. Qwen hits the edge of its ability and doesn’t ask for help. It keeps looping, burning power for half an hour. That is the same missing brake Ronacher worries about, in a smaller box. Ellis’s answer is discipline: he keeps the model on telemetry analysis and diagnostic dumps, where checking its work is cheap, because he knows it will hallucinate arithmetic. The privacy angle matters too. The win came from feeding private data to a model without contractual queasiness.

Qwen hits the edge of its ability and won’t ask for help. A GPU doesn’t buy you that self-awareness.

Post to X

The price of everything else

OpenAI and Anthropic cut their LLM prices by up to 80% within a few months. Why? Max Woolf walks a timeline of the price cuts at the two big labs, with a callout to DeepSeek.

Why it matters: The timeline points at open-weight pressure as the driver. Tokenizer swaps and benchmark theater are tactics; a price war is strategy. If you budget agent workloads, treat today’s per-token price as a number with a short shelf life.

IBM CEO says open weight models are now good and cheap on-prem IBM’s CEO says open-weight models now deliver roughly 90% of the quality at about 10% of the token cost, and enterprises are moving workloads on-prem.

Why it matters: An executive of a company that sells to enterprises is putting numbers on the shift. It’s his claim, not a benchmark, so check it against your own workload. The benchmark gap he describes keeps narrowing, which puts self-hosting on the table for teams that dismissed it a year ago. Ellis’s piece is the counterweight: the cheap model still needs a supervisor.

Tooling

JetBrains Thinkrail JetBrains shipped an agentic IDE built on the pi agent. It runs each task in its own git worktree, keeps “living specs” as durable project memory, and lets the agent build skills for itself.

Why it matters: Worktree-per-task is the right isolation primitive for running agents in parallel. The living specs are a bet on the Ronacher problem: keep the shared mental model in a file the agent has to read and update. Whether agents can maintain that file honestly is the open question. The self-extending toolset is the part I’d read the code on first.

The State of Context Engineering Drew Breunig’s overview covers how context fails, how to fix it, and where the line sits between deterministic and probabilistic work.

Why it matters: The framing isn’t revolutionary, but it’s a clean checklist for anyone building a memory layer or harness. The deterministic/probabilistic boundary is where I’d start. Every loop above gets safer when more of its judgment moves to the deterministic side.

Friction was a feature. The job now is to put some of it back on purpose, because the models won’t do it for you. 🪨