Monday, 13 July 2026

Claude Code's harness burns 4.7x more tokens than OpenCode before reading a prompt, a Microsoft study finds AI coding agents spread through peer pressure rather than mandates, and Tyler Cowen warns that AI abundance will overload people with meaning rather than replace it

Today's Lead

Engineering

systima.ai

Claude Code Sends 33k Tokens Before Reading the Prompt; OpenCode Sends 7k

A study logging live requests between two agentic coding tools and their model backends found that Claude Code incurs roughly 4.7x more token overhead than OpenCode before either has read a single word of the user's actual prompt — 33,000 tokens of harness scaffolding versus 7,000. Both tools performed identically well on the underlying tasks, so the gap isn't about capability; it's architectural. OpenCode maintains a byte-identical prompt prefix across requests, which lets its cache hit reliably and keeps per-request costs low, while Claude Code's more verbose system prompt and cache-invalidating request structure mean cache rewrites and configuration multipliers repeatedly balloon the bill for equivalent work. For teams that pay by the token and treat usage meters as a proxy for productivity, the finding reframes 'my agent burns through its weekly limit fast' as possibly a harness inefficiency rather than a sign of heavier real work — a reminder that the overhead layer wrapping a model, not just the model itself, is now a first-order cost variable in agentic coding.

Read →

Engineering

Scrapfly

Browsers Do Math Differently on Every OS, and Anti-Bot Systems Read the Bits

When Chromium 148 switched to platform-native math libraries for performance, it created an unintentional fingerprinting side channel: calling Math.tanh() (and several other trigonometric functions) now returns bit-for-bit different floating-point results depending on whether the browser is running on Linux, macOS, or Windows, because each OS ships its own math library with its own rounding behavior. That means a single JavaScript call — one with no permissions prompt, no API surface flagged as sensitive, nothing a privacy-conscious user would think to block — can silently reveal the underlying operating system to any site or anti-bot vendor that checks for it, layering on top of existing canvas- and WebGL-based fingerprinting techniques. Scrapfly's write-up walks through reverse-engineering the vendor math libraries closely enough to reproduce bit-compatible output across platforms, which is what it takes to make a scraper's browser fingerprint stop leaking its host OS. The deeper point is structural: performance optimizations that route through OS-native code paths keep reopening fingerprinting side channels that browser vendors close one at a time, and CSS trig functions and Web Audio APIs already look likely to be the next places this pattern repeats.

Read →

purplesyringa

Quadrupling Code Performance with a 'Useless' If

The author demonstrates a counterintuitive optimization: adding a semantically redundant if-check to a performance-critical loop — a branch that provably never changes the loop's output — produced a roughly 4x speedup in their benchmark. The mechanism is that the original loop was latency-bound, with each iteration's memory access chained to a data dependency on the previous one, which meant the CPU's out-of-order execution engine had nothing to overlap; adding the branch (correctly predicted almost every time) broke that dependency chain, letting speculative execution start the next iteration's work before the current one resolved, turning a latency-bound loop into a throughput-bound one. It's a sharp illustration of how modern CPU performance is governed less by instruction count and more by the shape of dependencies between instructions — and that sometimes the fastest fix for a data-dependency bottleneck is to introduce an instruction that does nothing, purely to give the hardware's speculative machinery a place to hide the wait.

Read →

Rust Blog

crates.io: Development Update

The crates.io team's twice-yearly update covers changes that add up to a meaningfully more capable registry: a new source-code viewer lets anyone browse the exact files cargo downloads for any published crate version — including generated files that never appear in the linked repository — without adding load to the API servers, since it's served entirely from a CDN-backed manifest-plus-range-request architecture. More structurally, crates.io is decoupling accounts from GitHub for the first time via RFC #3946, introducing native crates.io usernames as groundwork for eventually supporting login through other identity providers, a change the team is deliberately rolling out slowly given how deeply it touches account security. Other additions include unmaintained-crate warning banners sourced from RustSec, 'you might not need this dependency' hints for crates whose functionality has since migrated into the standard library, and the completion of a six-month Ember.js-to-Svelte frontend migration that shipped invisibly to end users but should speed up future iteration. Together it's a good snapshot of how much unglamorous infrastructure work — caching, accessibility, git-index performance, account security — sits underneath a package registry most developers only ever interact with via `cargo add`.

Read →

LeadDev

AI-Coding Agents Spread Through Peer Pressure, Not Mandates

Drawing on Microsoft research into GitHub Copilot CLI rollout, the piece finds that social proximity predicts initial adoption of AI coding tools far better than top-down mandates do: once more than a quarter of an engineer's immediate peers are using a tool, that engineer's own likelihood of trying it jumps 216%. The more interesting distinction is between trying a tool and actually keeping it — the decision to experiment is socially driven, contagious the way any workplace norm is, but sustained day-to-day use tracks whether the tool actually fits a given engineer's workflow, and peer pressure alone can't manufacture that fit. The practical upshot for engineering leaders is a warning against treating 'adoption rate' as a KPI to be pushed: mandating usage or measuring it too visibly invites impression management — people performing use rather than genuinely integrating a tool — whereas leaders modeling authentic use themselves and creating low-stakes space for experimentation seeds the same diffusion dynamic without the metric-gaming side effect.

Read →

George Hotz (geohot.github.io)

I Love LLMs, I Hate Hype

George Hotz stakes out a middle position between AI boosters and AI doomers: LLMs are a genuine, durable advance in computing — he compares them to compilers, a tool that changed what's practical to build without being magical — but the surrounding discourse of both utopian and apocalyptic hype is, in his view, mostly serving the interests of a small number of companies trying to consolidate power and capital around the technology. He's specifically skeptical of narratives that treat AI as civilization-altering in either direction, arguing that the actual day-to-day experience of using these tools is closer to 'better autocomplete and a very well-read pair programmer' than to anything requiring apocalyptic or utopian framing. It's a useful corrective for anyone whose information diet is dominated by extreme takes in both directions: the technology is real and worth taking seriously on its own terms, precisely because taking the hype at face value — good or bad — obscures what's actually being built and who benefits from the more dramatic story.

Read →

Simon Willison

Directly Responsible Individuals (DRI)

Willison traces the 'Directly Responsible Individual' concept — a single named person ultimately accountable for a project's success or failure — back to Apple, via the GitLab handbook's definition of it, and uses it to make an argument about where LLM-powered agents should never sit in an organization chart: never as the DRI. His reasoning leans on a 1979 IBM training slide stating that 'a computer can never be held accountable, therefore a computer must never make a management decision' — accountability, in his framing, requires the capacity to bear consequences, a distinctly human property that doesn't transfer to a model no matter how capable it becomes at the underlying work. As agentic coding tools take on more of the actual decision-making that used to require a human in the loop, the DRI framing offers a clean organizational principle for where the line has to stay fixed: an agent can do enormous amounts of the work, but somebody — a specific, nameable person — still has to be the one who owns the outcome, and that ownership is precisely the part of the job that can't be automated away.

Read →

Marginal Revolution

The Trump Administration's Threat to Scientific Research

Tyler Cowen rounds up a growing chorus of alarm — from the AAAS, The Dispatch, Dan Drezner, and Noah Smith — over a proposed rewrite of the federal government's Regulation for Federal Financial Assistance that would hand the OMB director sweeping discretion to cancel or redirect federal research grants for essentially any reason. The substantive worry isn't just this administration's specific priorities but the structural change: American science funding has historically been decentralized precisely to insulate it from being redirected by whoever holds political power in a given administration, an arrangement Cowen calls 'a historically unusual achievement that is easier to destroy than rebuild.' His own framing is that COVID policy, gender-policy fights, and now this rule change are cumulatively eroding an equilibrium in which independent science funding — like an independent judiciary — was treated as a bipartisan American value rather than a spoil of whichever party holds the executive branch, and that centralized control of science funding is the default everywhere else precisely because it serves whoever's currently in charge.

Read →

Marginal Revolution

'Markets Are Competitive If and Only If P != NP'

Philip Z. Maymin's paper makes a striking theoretical claim: whether markets can sustain competitive, non-collusive equilibria depends on a question from computational complexity theory. If P = NP, firms would be able to efficiently solve the 'collusion detection problem' — spotting a rival's deviation from a cooperative price-fixing arrangement even amid complex, noisy market signals — which would make punishment threats credible and collusion a stable equilibrium; if P != NP, that detection problem is provably intractable for markets meeting a natural hardness condition, so cheating on a cartel can't reliably be caught, and competitive behavior remains the stable outcome instead. Combined with an earlier result showing market efficiency itself requires P = NP, the paper produces a genuine impossibility result: markets can be informationally efficient or price-competitive, but a formal argument says not both. The empirical hook is that AI, by handing firms dramatically more computational power, is functionally pushing real markets toward the P = NP regime in practice even though the underlying complexity-theoretic question remains unsolved — a speculative but pointed explanation for the empirical rise of algorithmic collusion that emerges without any explicit coordination between firms.

Read →

Marginal Revolution

My Talk at DeepMind

In a transcript of remarks given at DeepMind, Tyler Cowen argues that the defining psychological problem of an AI-abundant future won't be a lack of meaning — the mass-unemployment fear — but an overload of it: 'the problem will not be how does my life get meaning, but how do I deal with all the meaning my life will have.' He expects total leisure time to rise as AI absorbs more work, but not smoothly or immediately, because a steep 'relative wage gradient' rewards working harder right now — anyone who delays engaging seriously with the current wave of capability falls behind peers who don't, a substitution effect operating on individuals regardless of whether aggregate labor demand is actually falling. Cowen is candid that this dynamic is exhausting even for someone who loves the subject: new frontier models now arrive so frequently that he finds himself hoping for a week's pause just to properly explore the last one before the next lands. The talk is a useful corrective to both 'AI causes mass unemployment' and 'AI trivially frees everyone for leisure' narratives — the actual near-term experience it describes is neither, but a psychologically taxing intensification of competitive pressure to keep up, borne earliest and hardest by anyone young enough to fear falling permanently behind.

Read →