Ronacher argues that the unit of programming work is shifting from the keystroke to the 'attempt' — a sandboxed agent run that reads a spec, writes code, runs tests, and iterates until green. Based on his hands-on experience running Claude- and Codex-style agents in parallel against Sentry's codebase, he claims developers will queue multiple agent runs and shift their throughput ceiling from authorship to review.
Ronacher's sharpest claim is that most codebases can't be run unattended for an hour because test suites are flaky, environments are non-deterministic, and specs live in Slack threads. He argues the productivity gains from agent loops only accrue to teams that invest in cheap, fast, trustworthy verification — making the next two years of meaningful gains about unsexy infrastructure work, not model quality.
One camp in the HN thread dismisses Ronacher's framing as hype, arguing that queuing sandboxed runs against a test suite is functionally what continuous integration has done for over a decade. They see the 'outer loop' as a rebrand of existing practice rather than a paradigm shift.
Commenters from shops already running agent-driven workflows argue Ronacher is simply describing their current reality, not a prediction. Their position is that teams still treating AI as autocomplete are underestimating how quickly the outer-loop workflow is becoming table stakes at frontier-adjacent companies.
Armin Ronacher — Flask, Jinja2, Sentry — published *The Coming Loop* and watched it climb to 362 on Hacker News in a day. The essay is short, blunt, and aimed squarely at developers who still think of AI coding as a fancier autocomplete. His thesis: the interactive inner loop that has defined programming since the REPL is being replaced by an outer loop where you specify, sleep, and review.
Ronacher's framing is that the unit of work is no longer the keystroke or the function — it's the *attempt*: a self-contained sandbox where an agent reads a spec, writes code, runs tests, observes failures, and iterates until either green or out of budget. You don't watch it. You queue several of them, go to lunch, and triage the survivors. The post leans hard on his own experience running Claude- and Codex-style agents in parallel against Sentry's codebase, and on the awkward reality that the human throughput ceiling is now *review*, not authorship.
The HN thread predictably split. One camp insists this is just rebranded CI. The other — including several commenters from Anthropic-adjacent shops — argues Ronacher is describing what is already shipping in their workflows, and that the holdouts are about to be lapped.
The interesting move in the essay is not the prediction. It's the diagnosis of what breaks when you actually try this. Ronacher names the real constraint plainly: most codebases cannot be run unattended for an hour because their test suites are flaky, their environments are non-deterministic, and their specs live in Slack threads. An agent that can write code faster than a senior engineer is still useless if it can't tell whether the code worked. The loop only closes when the verification step is cheap, fast, and trustworthy.
This is a much sharper claim than the standard 'AI will write your code' pitch. It implies that the next two years of meaningful productivity gains go to teams that invest in the unsexy infrastructure: hermetic builds, seeded fixtures, snapshot tests with stable outputs, schemas that double as contracts, and observability that surfaces a clear pass/fail signal. The teams that win are the ones who already took testing seriously. The teams that wrote 'we'll add tests later' are about to discover they cannot adopt this workflow at all.
Compare this to where the discourse was even a year ago. In 2025, the argument was about whether models could write production code. That argument is over — they can, badly or well depending on the rig. The 2026 argument, the one Ronacher is staking out, is about whether your *organization* can absorb code it didn't write keystroke-by-keystroke. That includes code review bandwidth, on-call rotations for AI-authored regressions, and the political question of who owns a bug the agent introduced at 3 a.m.
There's also a quieter economic thread in the essay. Running multiple parallel agents against a non-trivial repo burns tokens at a rate that makes pay-per-token API pricing genuinely painful — Ronacher hints at runs costing tens of dollars apiece. Subscription-tier access (Claude Max, GPT Pro, similar) makes the math work; metered API access often doesn't. The developers running ten background loops a day are not on the same cost curve as the ones still typing into a chat box, and that gap is going to surface in hiring posts within a quarter.
If you take Ronacher seriously, the action items are concrete and unglamorous. First, audit how long it takes a clean checkout of your repo to run a representative test suite and produce a binary pass/fail. If the answer is 'more than ten minutes' or 'depends on which intern set up the staging DB,' you are not ready for the outer loop. Fix that before you fix anything else.
Second, start treating your specs as machine inputs. The README that says 'authentication uses our standard pattern' is now technical debt. An agent reading that needs a link to a concrete example, a schema, or a failing test that pins the intended behavior. Several commenters on the HN thread reported that the biggest unlock in their team's agent workflow was not a better model — it was a `/agent-context/` directory of canonical examples the agent is told to mimic.
Third, rethink your sandbox story. Devcontainers, Nix shells, ephemeral preview environments, and per-PR databases stop being nice-to-haves and start being the substrate the whole workflow runs on. The companies quietly building internal platforms where any engineer can spawn a fresh, production-shaped environment in under sixty seconds are the ones whose agent loops will actually close. If spinning up a working dev env at your shop takes a half-day of Confluence-spelunking, no model will save you.
Ronacher is not predicting that programmers disappear. He is predicting that the part of the job that felt like *programming* — the tight interactive cycle — gets compressed into something more like *operating*: setting up rigs, defining specs, watching dashboards, and reviewing diffs you didn't author. Whether that sounds liberating or grim probably tracks how much of your identity is tied to the keystroke half of the work. Either way, the people who get a head start are not the ones with the fanciest editor — they are the ones who, two years ago, made their test suite boring and reliable.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.