Everything

Alex Kemper’s argument is that most companies are buying capable models and then running them over development processes built for a world where code was expensive and mistakes were slow to undo. His line for it:

After all, what good is it if the latest model completes a task in five minutes, but it takes another five days to get deployed?

The suggested shift is from preventing mistakes to making them cheap: isolation rather than permission, quick reversibility rather than careful review, parallelism rather than queues.

Atish Patel on Block’s Buzz, an internal workspace where several agents sit in shared channels alongside humans, each with its own persona, memory and seat. The question the post sets out to answer is which agents you should actually put on a job. Block’s answer is a tiered cast: QuickBee on cheap fast models for documented legwork, WorkerBee in the middle owning subtasks on its own, and SmartBee on frontier models kept for coordination and judgment.

The benchmarking is the useful part. Running real Buzz agents over live relays, they found a 5.5x price spread among the top scorers on Terminal-Bench 2.1 separated by only 8.9 points of score, which is a neat illustration that paying more stops buying much fairly quickly. On their long-horizon benchmark a SmartBee with two WorkerBees hit 71.5% against 59.1% for a solo agent, completing 20 of 44 tasks outright versus 15, or about a third more work.

Dhrumil Parekh on Sentry using its own Seer agent against its own repos. Seer root-causes incoming issues and opens fix PRs; an hourly Claude routine then scans a dedicated Slack channel for PRs opened in the last four hours, asks Seer to work out from commit history who knows the affected code best, checks the PR is still open, and pings that person to merge, close, or give feedback.

The reported effects are modest but consistent: roughly 21% more action on PRs, 13% better response within 48 hours, and 12.5% more PRs closed without merging. They read that last one as a good sign rather than a bad one, since the rejections tend to be duplicate fixes or cases where an engineer wanted a more thorough solution.

Guadalupe Aliseda-Canton on the infrastructure Duolingo built so its teams stopped rebuilding the same agent plumbing. An agent is a registry entry with a name, owner, system prompt, model, required MCP servers and output type; defining it once makes it callable from Slack, the CLI, internal sites and workflows without reimplementation. Standing one up used to be a multi-week project and now takes about ten minutes. The premise, in their words: “every useful agent needs a surprising amount of surrounding infrastructure.”

Underneath it is Temporal, chosen because agents take minutes, call external tools and fail unpredictably, so it “persists state, retries safely, and coordinates long-running work across systems.” Execution is decoupled from definition, which lets them run the Claude Agents SDK, Codex CLI or OpenAI Agents SDK behind the same registry entry, with LLM calls routed through an internal gateway for cost tracking.

Lilian Weng’s argument is that recursive self-improvement in AI will arrive through the harness, not through models editing their own weights. The harness, in her definition, is “the system surrounding a base model that orchestrates execution and decides how the model thinks and plans, calls tools and acts, perceives and manages context, stores artifacts, and evaluates results”. Because a harness is just code, it is a much more tractable target for improvement loops than the model itself.

Thorsten Ball opens by refusing to sell Orbs on their feature list, on the grounds that a list of ingredients has never made anyone want a burger. What he describes instead is how ephemeral sandboxed environments changed his own day-to-day work on Amp.

Three changes stand out. He spawns far more agents, because the friction of juggling local checkouts and environments no longer caps how many he can have going. Those agents run longer, eight to thirty minutes on work he would previously have kept local, with real testing attached. And they come back with evidence rather than a diff to audit: screenshots, videos, test matrices, in one case a demo video of a Rust desktop app that had been run headless in a sandbox.

Jon Eide and Aadil Hussaini on why Replit’s internal data agent got used, which they put down to trust rather than capability:

AI adoption is limited by trust. A user who gets burned by a confidently wrong answer will double-check the next one.

Their fix is an operational-truth layer: a version-controlled repository of business definitions, canonical metrics, source relationships, validation rules and documented past failures, which grounds every internal agent.

MIT Sloan and Stanford researchers had 1,000 adults ask chatbots for financial guidance, then simulated lifetimes of following it. The advice was better than the researchers expected: higher savings, diversification, sensible risk reduction with age. The catch is that outcomes tracked prompt quality. Women and less financially literate users ended up roughly $50,000 worse off by 60, and people unfamiliar with AI nearly $100,000 worse, because their prompts drew weaker advice. The models also leaned on rules of thumb, failing to adjust to shocks like unemployment.

Good advice being freely available but unevenly extractable is a striking new kind of inequality.

Allen Holub: if you really want to treat AI-generated code as a black box, your tests have to be immaculate and extensive, and he lists what that actually means, starting with all functionality and running through a long tail most suites never reach. “‘It works’ is not sufficient.”

The fine print on Uncle Bob’s gauntlet: not reading the code is only as safe as the test suite is complete, and software factories fail on exactly the qualities tests don’t price in.

Sean Goedecke argues that fully understanding your codebase is a small-team luxury. In large systems nobody understands it all, and effective engineers work from partly correct theories, making educated guesses and dealing with the consequences. He frames “pure” engineering (small codebases, complete understanding) and “impure” engineering (large systems, partial models) as different professional cultures, and treats understanding as one value to trade off among many, like performance or compliance.

A useful counterweight to cognitive debt: if full cognitive coverage was never on offer at scale, agents are not taking away something we actually had. Uncle Bob’s gauntlet of constraints is one way of living with that.

Manifest ran an LLM router for four months, classifying requests into complexity tiers and routing them across providers to cut costs, then killed it. A prompt alone does not reveal how hard a task is, prompt caching (cache reads 75 to 90 per cent cheaper) undercuts the savings, and switching models mid-workflow hurts consistency. Their conclusion: a good router stays sticky to one model, doing its job “by, ironically, not doing it”.

The HN discussion broadly agrees that frontier models are now interchangeably good for everyday work, and that nobody has time to learn each model’s quirks when a new one lands every week. The consistency point rhymes with cognitive coverage: switching tools constantly means never really knowing them.

Y Combinator’s software team has open-sourced qm, an agent platform for a whole company rather than one person, living in Slack and on the web. A headless TypeScript core with Postgres handles identity, dual-scoped memory and permissions (personal workspaces plus shared team projects), sandboxed tool execution, and crons for background automation. The harness itself is pluggable: Claude Code, Codex, OpenCode or Pi. MIT-licensed and designed to be forked privately rather than consumed as a product.

A production-scale data point for the ideas in anatomy of an agent harness and harness engineering.

“Your AI writes like a LinkedIn post. Make it write like a Boeing manual.” SimpleEnglish is a skill that forces LLM documentation into ASD-STE100, the controlled language aerospace has used since 1983 so a tired mechanic cannot misread an instruction: measured 72.9 per cent fewer violations across six Claude models, with AI slop dying as a side effect. The underlying observation (via @geogristle) is that controlled languages built for human safety turn out to be exactly the constraint that stops models writing filler.

In the HN discussion, several people want it for their own emails and Slack messages, one shows an output that is still wordier than real STE, and another notes drily that this is the third ASD-STE100 submission in a fortnight: this week’s trend, though maybe a good one.

Matt Rossman on the open-source benchmark Supabase built to find out how well coding agents actually build with its platform, covering “our CLI, MCP server, agent skills, and docs”. Scenarios are organised by product area (Database, Auth), by cross-cutting topic (SDK, observability), and by journey stage. There are two suites: benchmark scenarios for breadth, and regression scenarios that go deep on known failure modes.

Each run happens in a container with both a hosted-like Supabase stack and a local CLI project, so agents call the real MCP and CLI tools rather than a mock. Scoring mixes deterministic checks (whether a user can access certain data, or an Edge Function returns an expected result) with an LLM judge, and agents get one retry before the final grade.

Uncle Bob Martin (coding since the late 60s) no longer reads the code his agents write. Instead he surrounds them with extreme constraints, from unit and gherkin tests to mutation testing, and trusts code that has “run the gauntlet of all of my constraints and tests”.

The polar opposite of cognitive coverage: commit at zero understanding and bet the harness makes up for it. Harness engineering and Jason Swett’s TDD skill, taken to the logical end.

Mathew Hogan and Arvind Saripalli treat the development environment as a product whose users are agents. The scale of the shift is the reason:

In December, cloud agents authored roughly one in ten PRs merged to the Cursor monorepo. Today, they write more than half.

Getting a Mac-centric monorepo running on Linux cloud VMs meant a Cursor-defined Dockerfile carrying the key dependencies, along with network egress restrictions, secret scanning and redaction of secrets in tool results.

Jack Gordley on what went wrong as Grafana Assistant grew past its prototype stage, and the observability work that fixed it. The pain is specific and familiar:

Reviewing contributions to the prompt, tool set, and agent harness became a nightmare as changes piled on from multiple teams. Bespoke dashboards just weren’t cutting it.

His underlying point is that agents are inherently non-deterministic and heavily customized for a wide range of use cases, so the usual software review reflexes do not carry over.

Anna Mason, Sharadh Krishnamurthy and Anupam Upadhyay on Kai, Stripe’s Knowledge AI Platform: the same bet as coding agents, aimed at everything that is not coding. Coding tasks have fairly uniform workflows, and their point is that the rest of the company’s work does not:

Knowledge work is the opposite side of that spectrum.

It launched in April 2026 and 83% of Stripe employees are now weekly active, with connections to more than 1,000 internal tools and skills. Three layers: surface-agnostic APIs (a web app, Slack, and an embedded Chrome extension that puts Kai inside third-party tools), AgentStudio where domain owners build, test and monitor their own agents and skills, and an execution environment on LangChain deepagents and Kubernetes with per-session sandboxes, virtual filesystems and access control.

Jina Yoon’s framework: autonomy should depend on the task, not the model. “Trusting your agents just because the models got smarter is like skipping your seatbelt because you got a nicer car.” Two questions decide it: is the work easy to check, and are mistakes cheap to undo? That yields four levels, from assistant mode (hard to check, costly to undo) up to self-driving (easy to check, cheap to undo, like dependency updates), with PostHog examples of moving work up the ladder.

The checkability axis is doing the same work as the constraint-building in constrain the agent.

Zack Deveau on the part of an AI security system that is actually worth building. Models get swapped out every few months, so the engineering that lasts is the scaffolding around them: the test bootstrapping, the partitioning, the verification pass, the scoring. His line for it is that this is the part you’ll keep as new models come and go; this is where the innovation is.

The system is Dispatch, a Ruby orchestrator that runs security scans in eight stages. It finds and verifies the repo’s test commands, writes reusable architecture notes, catalogues and partitions files into token-sized clusters, then fans specialised hunting agents out across those partitions in parallel. Findings go through a verification stage that re-tests them with a different model, then deduplication and scoring, and finally a remediation stage that proposes fixes and opens PRs. Tests are the oracle throughout: a finding that cannot be demonstrated with a real test does not survive.

Rohit Agrawal and colleagues on a governance problem rather than a cost-cutting one. Thousands of Databricks engineers use coding agents every day, mixing Claude Code, Codex and Cursor, often several at once, and the spend is now one of the fastest growing line items in R&D. Their starting position is deliberately permissive: allow engineers to spend unimpeded by approvals and escalations, because AI leverage is the point.

A single monthly limit failed on both ends. It was slow to catch a runaway loop, since an automation could burn through a month of budget in an afternoon, and it created an approval queue: at their scale, somewhere between 500 and 1,000 engineers were hitting the limit every month. So they split it in two. A small daily limit, auto-resetting, catches runaway spend and can be raised by the engineer alone by acknowledging in Slack that the spend is intentional. A larger monthly limit handles real growth and needs manager approval, granted in tiers (2x, 5x, unlimited), scoped to a project and reverting automatically. The two are coupled by a fixed ratio and whichever binds first wins.

PostgreSQL internals visualised as a working 3D city: watch queries move through the engine like traffic. An independent educational prototype, openly flagged as early and reviewed, with a correction template for anyone who spots an inaccuracy. A playful companion to the Postgres survival guide.

The HN discussion is mostly delight (“I don’t know what I am looking at but it is fabulous”) plus useful feedback that the guided tour is too busy and should be interactive, and the tantalising idea of generating visualisations like this for whatever you’re currently learning.

A preliminary study finding that older people who avoided food in the four hours before bed did better on problem-solving tests, suggesting time-restricted eating may slow cognitive decline. Early-stage research rather than settled science, but a cheap intervention worth keeping an eye on.

Gergely Orosz “cannot help but see the concept of code reviews fading away”. A rock-solid, very experienced engineer he spoke to reviewed all their AI-generated code until Fable, then concluded the review was pointless and stopped, except for key parts. One anecdote, but from a careful observer of engineering practice, and consistent with where Uncle Bob and antirez already landed. The open question is what replaces review as the quality gate; Graphite is betting it doesn’t need replacing.

Anthropic removed over 80 per cent of Claude Code’s system prompt for the Claude 5 generation with no performance loss, and this post generalises the lessons: rules give way to judgment, worked examples give way to well-designed tool interfaces, everything-upfront gives way to progressive disclosure, and manual memory management gives way to auto-memory. For your own setup: keep CLAUDE.md thin and focused on genuine gotchas, prefer pointing at code (specs, test suites) over describing it, and let skills guide rather than constrain.

Practical vindication of the map-not-manual approach this repo’s AGENTS.md already takes.

Kenton Varda: building software by prompting agents without ever reading or editing the code “isn’t actually a new thing. It’s just called being an engineering manager”, a different skill with decades of accumulated practice behind it. The analogy is genuinely useful, but it has a gap worth holding onto: a human team carries far more durable memory and shared context between tasks than an agent team does, so the management playbook doesn’t transfer cleanly.

Dex of HumanLayer argues the lights-off software factory fails for a structural reason: RL training for coding models has no fast, reliable oracle for maintainability. “There is no penalty for eroding codebase maintainability”, only pass/fail on immediate tests, and design damage that compounds over months can’t be backpropagated. Harness engineering fixes the speed problem, not the quality problem. His answer: front-load alignment (product review, architecture, program design before coding), build in vertical slices, and keep humans reviewing inside constrained workflows: 2 to 3 times faster safely rather than 10 to 100 times faster into chaos.

A structural argument for why the dark factory level stays out of reach, and grist against Uncle Bob’s gauntlet: tests can’t price in design erosion.

The HN discussion ranges from “one of the best writeups of how RL shapes model behaviour” to accusations that software factories are Rube Goldberg machines and their proponents self-appointed experts, via the honest observation that human PR review was never that great to begin with.

Rohan Sharma, Liam Buchan and Dave Martin on running security agents at three points in Figma’s pipeline, all driven by one shared document. Agents review every PR, inject just-in-time guidance while code is being written when it touches risky patterns like new routes or permission policies, and audit the ten-year-old monorepo in budget-aware shards. The claim that ties it together is that the policy is the threat model: writing the trust boundaries, accepted risks and precedents down in one place was the work, and the three pipeline stages are just consumers of it.

That document is small. Ninety-nine lines, 2,560 words and 68 precedents. Its measured effect is large: without the policy the agents got 44.4% payout-weighted recall, with it 64.2%.

Alexander Belanger of Hatchet distils Postgres operations into tiers: schema design, indexing and short transactions first; then understanding the query planner (EXPLAIN ANALYZE, accepting that seq scans sometimes make sense) and tuning autovacuum before bloat accumulates; then the sharp tools like FOR UPDATE SKIP LOCKED queues, partitioning, and trigger-based migrations. The framing that sticks: “queries either seq scan or they don’t”, so optimisation is more binary than it feels.

The HN discussion mostly adds what the guide leaves out: monitoring and alerting for the few fatal failure modes, and a backup and restore plan, which several commenters reckoned is the real first item on any survival guide.

A design tool from a former Figma engineer that uses diffusion models as the design engine for agents: generate and iterate on UI designs, turn them into working products, and build reusable brand systems. Interesting as a bet that agents need a visual design medium of their own rather than driving human design tools.

Jason Clinton, Anthropic’s deputy CISO, on what happens to security review when code volume jumps and the old checkpoints turn into bottlenecks. His starting numbers: Claude authors about 80% of the code merged into Anthropic’s codebase, more than half of it merged by their internal version of Claude Tag with engineers setting intent and owning final approval, and engineers ship 8x as much code per quarter as they did from 2021 to 2025.

The pipeline he describes runs across all five stages rather than sitting at one gate. Automated project security reviews at planning; secure coding practice encoded in CLAUDE.md files and remote VMs with egress allowlisting at the coding stage; several specialised review agents on each PR in CI, with human approval still required for regulated and critical code; continuous AI-driven DAST scans against staging; and a single-purpose, restricted-permission agent doing alert triage in production. The consistent theme is hard access boundaries and identity containment rather than trusting instructions in a prompt.

Tyler Longwell’s premise is that the hard part has shifted: the bottleneck moved from intelligence to coordination. The models are good enough, but agents run in isolated sessions, and the questions that follow are practical ones. Does everyone get their own bot? If a team shares one, whose credentials is it using? What happens when you want to change models or agent runtimes?

Buzz is Block’s answer, a self-hostable workspace where people, agents and code sit in shared channels. It is built on Nostr, so an identity is just a keypair and every action is signed and verifiable. Agents get their own keys and are authorised by team members through narrowly scoped credentials, so you can tell which agent did what and on whose authority. Agents are addressed by mention in a channel rather than in a separate session. It speaks the Agent Client Protocol, so Claude Code, Codex and goose all plug in, and it hosts Git repositories as immutable content-addressed packfiles on object storage.

Wilson Lin on rebuilding Cursor’s agent swarm around a split between planning and execution: frontier models as planners that decompose a goal into subtasks, cheaper and faster models as workers that carry them out. The supporting machinery is the interesting part, including a custom version control layer taking about 1,000 commits per second, shared design documents with compile-checked references, neutral third-party agents to settle merge conflicts, and automatic file decomposition so no file becomes the thing every agent fights over.

The test was to implement the whole 835-page SQLite manual in Rust. With Grok 4.5 the new swarm reached an 80% test pass rate in four hours, where the old swarm spiralled and had to be paused before its second hour. The coordination gap is the clearest evidence: the old two-hour run produced 68,000 commits and over 70,000 merge conflicts, with its hottest file hitting 7,771 conflicts across 1,173 agents, while the new four-hour run stayed under 1,000 conflicts with a hottest file at 47.

Mozilla’s assessment of the open-model ecosystem: the gap to closed frontier models is down to about 4 points on the Artificial Analysis index, open weights now route the majority of OpenRouter tokens, Chinese models carry 46 per cent of routed tokens against 36 for the US, and inference prices have fallen roughly 50-fold in three years. One theme is that value is accruing above the model, in orchestration, tools, memory and permissions. As one HN commenter put it: “the harness is what takes these random and hallucinogenic models and makes them into something deterministic and useful”.

Pairs with harness engineering on the value-above-the-model theme, and with America’s open-model paradox on how it got this way.

The HN discussion spent as much energy on the report’s scroll-animated presentation as on its substance (“Open ships easy. Open deploys hard.”), but the sharper thread speculates that open weights eventually undercut the frontier labs’ economics entirely: hyperscalers run them without licensing fees while the labs carry the training costs.

Boris Cherny (creator of Claude Code) hears the same thing everywhere: one person is 10x-ing their output with Claude and the rest of the org hasn’t caught up. He maps adoption as four steps, and the key observation is that tokens alone never move you forward: each step needs the next set of bottlenecks broken and the next set of guardrails built. In practice that means giving Claude ways to verify its own work end to end, auto permissions, automated code and security review, and interfaces for managing multiple agents. On measuring return, prefer the counterfactual to usage dashboards: would you have spent the engineering hours anyway, and what would they have cost?

Dean Meyer and Konstantine Buhler on distillation asymmetry. Qwen’s share of new open-model fine-tunes rose from 1 per cent in January 2024 to 69 per cent by February 2026, and Western labs now legally use Chinese open weights as teachers (Thinking Machines bootstrapped Inkling’s fine-tuning with synthetic data from Kimi K2.5) while equivalent use of GPT or Claude outputs is prohibited by their terms. The flow runs: Western frontier models → alleged unauthorised extraction → Chinese open weights → lawful Western post-training. Every Western frontier advance creates another teacher for Chinese labs, but not for Western ones.

Amjad Masad and Scott Kennedy on running Replit as what they call a self-driving company, meaning agents deployed across most functions rather than just engineering. Engineering agents write, review and test code and root-cause production incidents; a manager agent spawns others to coordinate work loops; and there are sales, data, support and marketing agents, plus one that analyses user feedback and validates its own improvements through A/B tests.

The numbers, all self-reported, cover early January to late June: lines of code up 5.8x, and 2.9x more code per engineer once you control for hiring, with the team roughly doubling. The quality metrics they put alongside that are flat rather than improved, which is the point they are making: code review latency flat, PR reversion rates flat, production incidents flat, mean time to mitigation falling. Agents now save about 30% of human PR review time, and escalated support tickets resolve 60% faster.

Tariq’s formula for the ideal prompting technique: thin prompts, thick artifacts and context, thin skills. Nine words that compress a lot of hard-won practice: put the effort into durable context the agent can read (specs, tests, docs), not into elaborate per-task prompts or over-prescriptive skills.

Dan Austin built a pipeline where an agent is handed a training task (“teach a model to do X”), writes a complete RL training job (environment, reward, dataset, hyperparameters), and submits it to real GPUs. Then he RL-trained the agent itself, rewarding it when the models it trained got better. Reward climbed from about 0 to 0.63 over 54 steps, and transferred to a held-out task family. Everything is open-sourced, including write-ups of the failed pilots.

Brian Scanlan on what Intercom learned running an internal marketplace of Claude Code skills, where 153 contributors, about 31% of R&D, wrote 267 skills in the first three months. At that volume the question stops being whether to write skills and becomes how to tell the useful ones from the ones quietly making things worse.

His good skills do one thing, wrap it in a real feedback loop, and lean on deterministic scripts rather than hoping the model improvises correctly. They come with maintained evals, disclose context progressively instead of dumping everything up front, carry safety guardrails, and have a named owner. The bad ones fail in recognisable ways: they produce the same errors every run, nobody checks their output, their evals are graded by something unqualified to grade them, they are too big for Claude to actually read, or they are hard to invoke so nobody does.

Sumuk’s field notes on GPT-5.6-Sol: “the most OCD model I’ve used”, frequently one-shotted by random nits in the codebase, prone to writing piles of tests to fix them, and slow at this iterative fussing even in fast mode. Model reviews measured in billions of tokens of daily use are becoming their own genre, and often say more than benchmarks.

On your own machine an agent leaves two bad options: approve every command and babysit the prompt, or --dangerously-skip-permissions and hope nothing is one rm -rf from disaster. Clawk is the third option: cd into a repo, type clawk, and Claude Code (or Codex, or a shell) works inside a disposable Linux VM with your code mounted. The agent gets full autonomy inside walls, instead of limited autonomy on your laptop.

The HN discussion asks the obvious question (why not just Docker: answer, kernel isolation), jokes about agents escaping container jail, and reveals a crowded field: Fly Sprites, virtdev, take-ai-control. Agent sandboxing is having a moment.

Can Bölük analysed token distribution across about two million agent tool calls: 91 per cent of tokens go on reading the codebase, 9 per cent on edits. That kills the intuitive plan-with-a-frontier-model, implement-with-a-cheap-model split, because the cheap executor has to reread everything the frontier model already read; in his tests the split actually cost 14 per cent more than the frontier model working alone. A plan document is “a literal postcard, describing a journey to a model that never took it”.

Their fix, prewalk, hands over the frontier model’s actual context window after its first successful edit: 92 per cent of the performance at 53 per cent of the cost.

Steve Krouse’s problem with spec-driven development: most software can’t be specified up front, because “software is a creative act, where you figure out what you’re building as you build it”. You need your hands in the details, reacting to incremental versions.

A useful tension with the constraints school (constrain the agent, Uncle Bob’s gauntlet): constraints assume you know what to constrain.

A visualisation tool that replays coding-agent sessions on a 3D map of your codebase. Watching where the agent walked, file by file, is a novel angle on the understanding problem: not reading the diff, but seeing the journey that produced it.

Salvatore Sanfilippo: many devs aren’t maximising automatic programming because they still look at the code. “Doing it makes you the bottleneck. Your time is better invested in new ideas, QA, design, and asking yourself what is your goal.” Striking from the author of Redis, a codebase famous for being read line by line.

Same camp as Uncle Bob, and the opposite of the short leash method.

Dax Raad: being in the loop matters, but people misread what the loop is for. Your job isn’t to micromanage the agent into executing steps the way you would; “it’s to come up with cool things for it to work on”. A neat one-line answer to the bottleneck question Patrick JS raised: deciding what should exist.

Doug Turnbull’s case against handing all the typing to agents is not that they write bad code. It is that writing code is how he finds out what he actually thinks:

Writing code helps me think. English is an under-specified language.

The other reason is that touching the code is how you notice it is rotting. He calls this experiencing fragility: if it is hard for him to build on something without breaking it, an agent will have a worse time still. Prompting from a distance hides that signal.

Jarred Sumner’s reason for the rewrite is not that Zig was slow. It is that Bun kept shipping use-after-free crashes, double frees and leaks in things like node:zlib, node:http2 and the CSS parser, and style guides plus code review were not catching them. Rust’s borrow checker enforces at compile time what Bun had been trying to enforce by discipline.

The execution is the striking part. Excluding comments, Bun was 535,496 lines of Zig. Sumner ran four worktrees with sixteen Claude instances each, about 64 at once, with every implementer’s diff handed to two independent reviewers told only to find bugs. Compiler errors became a work queue, roughly 16,000 of them. It took 11 days, 3 to 14 May, 6,502 commits, peaking at 695 commits an hour, and around $165,000 in API pricing.

Public benchmarks were not telling Databricks what it needed to know, so it built its own from real pull requests against its multi-million-line codebase, which spans more than ten languages including Python, Go, TypeScript, Scala, Rust, Java, Bazel and Protobuf. Tasks were graded against the real test suites rather than an LLM judge, with git history sealed so agents could not read the original solution. Roughly a quarter of the tasks are low complexity and about 60% medium.

The headline finding is that no single model wins. As the authors put it, the Pareto frontier for coding tasks includes models from OpenAI, Anthropic and open source, and the sensible strategy is routing by task difficulty rather than paying for the most expensive model every time. Opus 4.8 scored 87% at $1.94 a task; GLM 5.2 tied with it statistically at $1.28; Sonnet 5 came in at 81% and $2.09, costing more per task despite the lower per-token price.

Sam Wiskow on how a three-person pod at GitLab, plus floating engineers, used agents to move 121 rate limit keys onto a new implementation across 30-plus merge requests and 14 numbered specs. The work ran in six cohorts, one more than the five originally planned.

The loop was rigid on purpose: read the epic, write a spec, run an adversarial review on the spec with a two-round cap before a human is pulled in, implement only once blockers are cleared, verify with explicit evidence, adversarially review the merge request, then escalate for human review and merge.

Anthropic researchers find a “J-space” in Claude: a small set of word-linked patterns that behaves like the global workspace of consciousness research. Claude can report what’s active in it, modulate it on request, and use it to mediate multi-step reasoning, while routine processing bypasses it entirely. It emerged in training rather than by design. Useful for safety (a lens onto hidden thoughts, like recognising test scenarios or fabricated data), and provocative on the question of access consciousness, while claiming nothing about phenomenal consciousness.

The Claude Code team’s taxonomy of loops, pinning down a term the discourse had left fuzzy: agents repeating cycles of work until a stop condition is met. Turn-based (the ordinary agentic loop), goal-based (/goal with an evaluator model checking your stop condition: “get the Lighthouse score to 90, stop after 5 tries”), and time-based (/loop and /schedule for recurring work or polling external systems). The practical advice: encode your manual verification steps as skills so the agent can check its own work end to end, and make the checks as quantitative as possible.

Simon Willison’s 124th release of sqlite-utils, and the first major version bump since 3.0 in November 2020. The headline feature is schema migrations, a sequence of changes to apply to a database plus tracking of which ones have already run. Nested transactions via a new db.atomic() context manager built on SQLite savepoints, and compound foreign key support, come with it.

The part worth remembering is how he tested it. He set frontier models loose on the pending changes: Claude Fable 5 wrote twelve Python scripts and turned up four release blockers plus ten further issues, and GPT-5.5 wrote another five. One of the issues it surfaced had been open since October 2020. The upgrade guide and the release notes were written entirely by Fable 5, Claude Opus 4.8 and GPT-5.5.

There’s no doubt in my mind that sqlite-utils 4.0 is a significantly higher-quality release than if I had built it without the assistance of the latest frontier models.

Patrick JS: agents are solving coding, not engineering, and engineering is exactly where the current problems live: taste, judgment, constraints, systems thinking. “The bottleneck didn’t disappear. It moved from ‘can you write the code?’ to ‘can you tell what should exist?’”

Russell Brandom interviews Vercel’s Guillermo Rauch, whose central question is whether the model and the agent stay coupled. Rauch’s bet is that they come apart, and that companies will want to mix providers rather than commit to one lab. His reasoning is commercial rather than ideological: once you are optimising for production instead of demos, you start looking at price/performance, and at that point Gemini, DeepSeek and open-weight models become real options alongside OpenAI and Anthropic.

The numbers he gives for Vercel’s own vantage point: 6 million deployments a day, half of them triggered by coding agents, and more than a trillion tokens a day through the AI gateway. He names two killer apps for agents so far, coding agents and internal corporate agents that need careful access to company data, with Vercel Sandbox aimed at the second by restricting what an agent can reach without dulling it.

The poster can’t reach flow state with coding agents: “a bicycle that just brakes abruptly every couple minutes. I stop, wait, review, prompt again.” The thread is a good sample of 2026 workflows people have built around the problem: TODO files as free-text prompt queues, JSX templating languages for context piping, custom harnesses running in VMs with their own email accounts and Linear boards, and agents generating diagrams of their changes at different abstraction levels to speed up human understanding.

Armin Ronacher on a regression he hit in his own agent, Pi: Opus 4.8 and Sonnet 5 get better at the task and worse at calling the tool. Pi’s edit tool takes an edits array of objects with only oldText and newText. The newer models produce the correct values and then append invented keys, things like requireUnique, oldText2, matchCase and in_file. The target text is right; the object around it has junk bolted on. One user’s session saw Opus 4.8 fail roughly 20% of the time.

His explanation is that the models were post-trained against Claude Code’s harness, which is forgiving: it accepts parameter aliases, filters unknown keys and silently repairs bad calls. Claude Code’s own edit tool is flat (file_path, old_string, new_string) rather than Pi’s nested shape, so when a model meets the unfamiliar schema it falls back on learned priors about what an edit call looks like. The failures cluster at high-entropy points, notably the decision whether to close the JSON object after an escaped multiline string. Stripping thinking blocks halved the failure rate; strict tool invocation removed it in testing.

Greg Slepak’s counter to full delegation: plan and break down tasks first, review every diff before granting permission, never YOLO mode, commit after each subtask, and require AI-assisted PRs to be self-reviewed before human review. “You keep yourself in the loop at all times instead of removing yourself.” His claim is that even Fable 5 writes inefficient, ugly code without active oversight.

The direct opposite of Uncle Bob’s approach: maximum cognitive coverage, paid for in speed.

The HN discussion split neatly: half thought this is just how anyone serious already works (“are you guys just YOLOing everything these days?”), half thought it’s slower than writing the code yourself, plus a jab at the genre of AI-workflow advice written after a couple of months of personal use.

An AI code review platform built around stacked PRs: break large changes into small sequenced ones, have AI review each, and merge through a stack-aware queue. Used by Shopify, Ramp and Asana. Bookmarked as the strongest productised bet that code review stays central in the agent era; the opposite wager to Gergely Orosz’s observation that reviews are fading.

Patrick Nadeau at Autodesk Research argues that spec-writing discipline puts the burden on the wrong side: build constraints into the agent’s environment instead. He sorts them into three kinds: generative (tests, and especially test oracles that compare against a reference implementation), interpretive (give the agent a debugger so it can test its hypotheses about existing code), and elicitative (have it interview stakeholders to resolve ambiguity before implementing). The common thread is grounding the agent’s output in an external source of truth.

Same instinct as Uncle Bob’s gauntlet of constraints, but engineered into the system rather than bolted on.

Matt Pocock reports that /writing-great-skills, a skill whose job is writing other skills, has become his most-invoked one. Pleasingly recursive, and a signal of where agent customisation is settling: the skill file as the unit of teaching an agent how you want things done.

Chantal Kapani on the gambling-machine quality of AI coding: intermittent rewards, an immediate next step to every problem, and no natural stopping points. 45 per cent of engineers report working more hours than last year, and CTO burnout has more than doubled. Steve Yegge compares the random rewards to casinos: “your brain gets a chemical bath”. Suggested defences are unexciting but sane: time-box sessions, separate exploration from execution, treat recovery as maintenance.

Clinton Carpene, Alex Rosenzweig and Andrew Kitis on the design decisions behind CodeCrucible, Block’s open-source LLM-driven SAST tool. The post is deliberately written as a blueprint rather than a product pitch:

The version you should build will not look exactly like ours and that’s the point.

The central bet is whole-repo concatenation: flatten the whole codebase into one model call rather than feeding the model snippets that a rule engine has already picked out. Their argument against retrieval is that snippet-anchored systems only show the model what the upstream engine already knows to look at. If no rule fires, the LLM never sees the code. They also think the field underrates how much context modern models can hold, noting that a 200K-token window on a 50K-token repository is well inside its comfort range, and that code compresses far better than the prose RAG systems were tuned for. Chunking is only a fallback, and when it happens it keeps file boundaries and imported files together rather than slicing to fit a token ceiling.

Sergiy Dybskiy built a schedule assistant for AI Engineer World’s Fair 2026, with cheap open-weight models serving anonymous visitors and better ones for signed-up users. Asked who the famous speakers were, the free tier confidently named Sam Altman, Andrew Ng and Fei-Fei Li, then invented “Chris Hagen, Founder of Stability AI”. Pressed on its source, it claimed the names came from its getTracks tool, which only ever returned track names.

The point of the piece is what the monitoring showed: 44 LLM calls, 92K tokens, 0 errors, under a cent in cost. By every automatic signal the run was fine.

A tool ran, so the answer reads as grounded. You only catch it by opening that tool call and seeing tracks where speakers should be.

Sam Rose hand-ported the core of Kubernetes to TypeScript so it runs entirely in the browser: pod lifecycle, cluster networking, DNS and deployment controllers, about 100,000 lines written with LLM assistance, every line reviewed, and 2,000-plus tests checked against a real k3s cluster. It ships at roughly 140KB gzipped and exists to power interactive Kubernetes tutorials. A nice data point for what one developer educator can now build with agents.

The HN discussion found the workflow more interesting than the artifact: the review discipline and testing against a real cluster is what separates it from vibe slop, with one commenter suggesting we’re on the cusp of only needing to read the tests. That, and the inevitable jokes about Kubernetes complexity.

Suhail Doshi has stopped reading interesting posts, tweets and papers in the moment. Everything gets queued, and when he has a block of time (in an Uber, before bed) he asks an AI to teach him each item with a specific prompt, instead of doomscrolling. A simple reframe: treat the feed as an inbox, and use the model to turn each item into a lesson.

A free handbook of the unglamorous fundamentals of building financial software: representing money (precision, rounding, currency, FX), double-entry ledgers, value time versus booking time versus settlement time, immutability and audit trails (and how that squares with GDPR), idempotency and full resumability of money flows, reconciliation, and controls like four-eyes and segregation of duties. Appendices walk end-to-end flows such as a crypto withdrawal. The kind of domain knowledge that usually lives only in the heads of people who’ve been burned.

In the HN discussion, a fintech veteran vouches that it matches five years of hard lessons (answering the now-obligatory “is this AI slop?” question), and the sharpest thread warns against using minor-units integer amounts as an interchange format, however clever it feels.

Anthropic’s collection of runnable guides for building with Claude: tool use, RAG, structured extraction, multi-agent orchestration, extended thinking, prompt caching, batching, and deployment patterns. Worth remembering as the first place to look for a working example of an API feature before writing one from scratch.

John Phamous on the gap between an agent producing working UI and an agent producing UI that matches how your product already behaves. His framing of the problem:

Code shows agents what shipped, not why one component, phrase, or interaction became your standard.

Vercel’s answer is a product-design agent skill in the repo, split into references/ for the judgement calls, exemplars/ for decisions taken from shipped PRs along with mistakes to avoid, and a coverage-gaps.md listing what has no agreed standard yet. Anything a linter can catch reliably becomes a lint rule instead, so the skill carries only what needs context. The skill also recognises five request modes with different obligations: shape, implement, review, copy and harden. One number worth noting on skills generally: in separate Next.js evals, agents failed to invoke an available skill in 56% of cases, which is why the post pushes explicit triggers and firm boundaries.

Haggai Roitman’s practitioner’s guide to agentic AI, covering the whole stack on the argument that building good agentic systems requires understanding every layer: transformers, GPU infrastructure and training at the bottom, then alignment and reasoning (RLHF, DPO, chain of thought), RAG and memory architectures, agent design patterns, multi-agent coordination, and evaluation and deployment at the top. Each chapter pairs theory with code examples and references. Bookmarked as a reference to dip into rather than read cover to cover.

Steve Yegge’s argument is that the capability curve keeps going up but most people will stop being able to see it. Frontier models have crossed into territory governments will treat like weapons, Fable’s brief shutdown being the first sign, so the genuinely superintelligent systems get locked away while everyone else works with what is left. Hence the title:

The intelligence curve is as real as the Earth is round, but just as flat from where you stand.

He adds two personal limits on top of the policy one: a demand horizon, meaning the hardest problem you actually have, and a discernment horizon, meaning your ability to tell whether the output is any good. Past those, a better model looks the same as the one you have.

Simon Willison on a new Datasette feature that lets you host self-contained HTML and JavaScript applications inside a Datasette instance, running read-only SQL against its databases. His demo is a timeline app over 1,953 items of news, blog posts and releases.

The interesting part is the sandboxing, since the whole point is letting users publish code that other users will run. Apps load in an <iframe sandbox="allow-scripts allow-forms"> so they get no cookies and no localStorage, and a CSP header blocks outbound requests so an app cannot phone data home. Once set, that policy is immutable for the content of the frame. The app talks to the parent through a MessageChannel(), which closes automatically if the page navigates away. Reads are allow-listed read-only queries; writes have to go through pre-configured stored queries.

A browsable queue of Wikipedia rabbit holes and evergreen YouTube videos that have been popular on Hacker News.

Matei Zaharia, Kasey Uhlenhuth and Corey Zumar argue that coding agents now need a layer above the harness. Their users run Claude Code, Codex and Pi side by side, and every harness has its own session model, its own permissions and its own way of being shared, so nothing composes. Omnigent is Databricks’ answer: a common API over the lot of them, open sourced under Apache 2.0 and still alpha at the time of writing.

The abstraction rests on a claim that all these tools have the same shape underneath, messages and files in, text streams and tool calls out. Wrap each agent in a sandboxed session behind that uniform interface and you can add the things individual harnesses do not offer: session sharing by URL, web and mobile and API access to the same run, cloud execution, per-session spend limits, and security policies that track state rather than just allowing or denying calls.

Satya Nadella used the term “cognitive coverage” on Hard Fork to describe how much of the code a developer understands when they commit it. Basically the flip side of cognitive debt, with a nice parallel to test coverage.

Simon Willison gave Claude Fable 5 a one-line prompt about a horizontal scrollbar showing up in a modal in his Datasette Agent project, and then watched what it did to track the bug down. His summary of the model:

the best way to describe it is relentlessly proactive. It knows a whole lot of tricks and it will deploy pretty much any of them to get to its goal.

The trail is the interesting part. It worked out how to run the local dev server, drove Chrome through Playwright, turned on visible scrollbars, cycled through Firefox and WebKit, worked out that his default browser was Safari, built a standalone textarea-scrollbar-test.html to isolate the behaviour, wrote its own small Python CORS web server to collect measurements back out of the page, scripted through the Web Component shadow DOM, then patched a template to confirm a fix and reported how to make it properly.

Daniel Beauchamp and Alex Pilon on an internal platform built around a single observation: at Shopify, sharing an internal project had become harder than building one. Quick removes the deploy step entirely. You upload a folder of HTML and your site is live, with no frameworks, deploy pipelines, or config files. Since launching in July 2025 it has grown to more than 50,000 sites, and over half the company has created at least one.

The implementation is deliberately dull. Sites are folders in Google Cloud Storage buckets, gcsfuse mounts the buckets so NGINX can serve them as ordinary files, a wildcard config maps hostnames to folders, and an Identity-Aware Proxy means every request arrives already authenticated as a Shopify employee. The whole thing runs on one VM for about $200 a month. Because identity is handled at the edge, they could add shared backend services on top: a database, file uploads, LLM access, data warehouse queries, WebSockets.

Daniel Botha’s point is a separation most agent setups collapse by default: where your agent lives and where it runs code are two entirely separate considerations. Put the control loop, the part calling the model and deciding what to do next, on a durable long-lived machine. Run every shell command somewhere disposable, so an agent cannot delete the ground it is standing on.

Four patterns follow. Brain and hands split as above. One sandbox per session, started fresh and spun down when idle, which keeps isolation without paying for machines nobody is using. Credentials injected into the sandbox for the length of a single command rather than left sitting on disk. And copy-on-write snapshots taken before anything risky, so a bad step is a restore rather than an incident.

Jason Swett argues that agents only write useful tests if they are given a concrete process to follow. Models may know about TDD in the abstract, but they default to vague, performative, or overcomplicated tests.

Basing the agent loop on “specify, encode, fulfil” gives the agent an executable target, keeps speculative implementation (code/feature bloat) in check, and makes refactoring easier to review.

David Heinemeier Hansson’s case is that open source spent decades winning everyone the right to change software, and that the projects now barring AI-assisted contributions are quietly deciding “everyone” had limits. He opens on exactly that:

The open source movement spent decades fighting for everyone’s right to change software, through free access to code and permissive licenses to release improvements. But at the dawn of the AI revolution, as this mission is finally being broadly fulfilled, it’s clear that “everyone” never actually meant everyone to some.

Javier Moreno and Burke Libbey on the infrastructure under River, Shopify’s Slack-native coding agent, with River itself credited as a co-author of the post. The scale is the reason to read it: one in eight merged pull requests across Shopify is coauthored by River, and in one 30-day window there were 59,918 sessions across 5,170 Slack channels, touching the work of over 7,000 people, producing 3,536 merged coauthored PRs. Median session runs 19 minutes and 50 tool calls.

The design idea is to decouple the brain from the hands. Aquifer splits into a session (durable identity, append-only event log, Postgres-backed), a harness (the agent loop, which reads history, calls the model and emits tool intents) and a sandbox (filesystem, shell, repo), with a gateway, credentials proxy and observability pipeline around them. Because the session is an event log rather than a process, it survives restarts and model swaps: the session is the thing that must survive.

Max McGuinness and colleagues on why containment has to be environmental rather than behavioural: rather than supervising what the agent does, we supervise what it’s able to do by enforcing access boundaries. Model-layer defences are probabilistic and will eventually fail, so the hard boundary has to sit underneath them. Their rule for which boundary to trust:

The weakest layer is the one you built yourself. gVisor and seccomp have been hardened against well-resourced adversaries for far longer than agentic AI has existed.

Three concrete patterns, not one generic sandbox. claude.ai uses ephemeral containers on gVisor with seccomp syscall filtering and a per-session filesystem. Claude Code uses an OS-level sandbox, Seatbelt on macOS and bubblewrap on Linux, where reads are allowed, writes are confined to the workspace and network is denied by default; that cut permission prompts by 84%, and the runtime is open source so the boundary is auditable. Claude Cowork goes furthest, running a full VM on the platform hypervisor with a vsock boundary, three mount modes, and the agent loop running outside the VM while code executes inside.

Two posts in one from Armin Ronacher: what agent-generated contributions are doing to an open source tracker, and how he uses his own agent, Pi, to cope with them. Pi is now part of Earendil, and it auto-closes issues and pull requests from non-approved accounts, which gave him a clean number to pull.

Over 90 days, 3,145 external issues and PRs arrived from outside the team. 2,504 were auto-closed. 17% were reopened, rising to 26% if you count issues later referenced by a merged PR or main-branch commit. For pull requests specifically it is worse: 60 of 714 auto-closed PRs were eventually merged, about 8%. So the blunt filter throws away real work, and he is clear that it still beats the alternative.

Candace Shamieh, Teddy Gesbert and Daniel de Juan argue that AI makes the usual output metrics useless. PR counts, commits and lines of code all go up whether or not anything valuable shipped, so the thing to measure instead is developer experience: the feedback loops, cognitive load and flow state around the work. They cite GitClear’s analysis of over 200 million lines of code, which found code churn nearly doubled after AI adoption became widespread.

A developer can now produce significantly more lines per session, but higher volume doesn’t guarantee that the code is stable, maintainable, or successfully running in production.

Aaron Wang’s point is that adoption is a distribution problem, not a capability one. Duolingo found engineers would not set up MCP servers themselves, so rather than write a better setup guide they put the agent where people already were:

If people won’t configure MCP themselves, we can bring MCP to them.

@DuolingoAI is built on the Claude Agent SDK and Slack Bolt, with internal HTTP-based MCP servers fronting Honeycomb, Grafana, Sentry, PagerDuty, GitHub, Jenkins, Jira, AWS and BigQuery. Write operations get Approve and Cancel buttons, tool access is gated by a role-based allowlist, and a validation sub-agent cross-checks links and names before a response goes out. DMs and private channels are not logged.

Armin Ronacher’s diagnosis is that what holds local models back is not the models but the fragmentation and missing polish around them. Running one locally means choosing an inference engine, a model, a quantisation, a template and a context size, then wiring up JSON config, with effort scattered across llama.cpp, Ollama, LM Studio, MLX, Transformers and vLLM. His section heading sums it up: Runnable is not finished.

His test case is coding agents, where the shortfalls are specific rather than vague. Tool parameter streaming, which most local setups do not support, matters as much as token streaming does elsewhere: seeing parameters arrive tells you what edits are happening, so you can interrupt instead of burning tokens on a wrong path. Slow local models also break assumptions elsewhere in the stack, such as dead-connection timeouts that misfire when five minutes can pass between tokens.

Addy Osmani separates cognitive offloading (delegating while keeping your own judgment) from cognitive surrender (accepting AI output without forming an understanding of your own). Engineers are unusually exposed: code looks correct by default, and productivity metrics can’t tell understanding from approval. The habit compounds into what he calls comprehension debt. His countermeasures are small and practical: form an expectation before reading the output, read diffs critically, ask the model for counter-arguments, and notice when fatigue is making you rubber-stamp.

Another name in the growing vocabulary around cognitive debt and cognitive coverage.

Kesha Mykhailov and Niamh Young make the case that review became the bottleneck once agents started writing most of the code, and that the answer is to automate the gate rather than slow the line. Over 93% of Intercom’s PRs across their two main codebases are now agent-driven, and over 19% are auto-approved with no human reviewer in the loop. In the first four weeks of broader rollout, 497 PRs went fully autonomous, with Claude writing the code and their AI approval system reviewing, approving and shipping to production.

The review agent splits the job into sub-tasks handled by independent agents, each looking at a different thing: whether the change matches the problem description, safety concerns, logical correctness, best practices. Strict size and complexity limits keep large changesets out of auto-approval, and every decision is logged, labelled and auditable. Engineers can ask for a human at any point.

Ryan Skidmore on the code review system Cloudflare runs across its own repos. The argument against off-the-shelf tools is that they “just didn’t offer enough flexibility and customisation for an organisation the size of Cloudflare”, and the argument against a single reviewing model is that one generic prompt produces noise. Instead the system launches up to seven specialist reviewers covering security, performance, code quality, documentation, release management and compliance, then has a coordinator do a judge pass that deduplicates findings, moves them into the right section and drops nitpicks and false positives.

Cost is controlled by sizing the review to the diff. Trivial changes get two agents at around $0.20, medium ones four, and anything over 100 lines gets the full seven or more at around $1.68 on average. Models are assigned by tier too, with the strongest reserved for the coordinator and lightweight models handling documentation and release checks.

Brian Scanlan, a senior principal engineer at Intercom, talking to Claire Vo on “How I AI”. This is a podcast episode page rather than a written account, so the detail comes from the episode summary and transcript rather than an engineering write-up.

The headline number is narrower than the title suggests. What doubled in nine months was merged PRs per R&D employee, not output or delivered value, and a merged PR is a unit that AI tooling makes easier to produce in quantity. Worth holding that in mind before reading it as a doubling of engineering velocity. Alongside it: 100% of engineers, plus designers, PMs and TPMs, now ship code via Claude Code.

John Smart’s Transcension Hypothesis proposes that advanced entities or civilisations may not expand outward across the standard universe indefinitely. Instead, they may transcend our observable frame by moving inward toward denser, more computationally efficient, or more information-rich domains.

Rhea Purohit walking through how Linear uses its own agent internally, told as three traced journeys rather than a feature list. A customer email arriving through Intercom becomes a scoped issue with the full back-and-forth attached, gets routed to the right team automatically, and ends with someone closing the loop with the customer. A Slack complaint becomes a scoped issue the agent then investigates using code intelligence and internal MCP servers. And a PM who noticed a missing filter while testing had the agent open both the issue and the pull request.

David Oks argues that AI job loss will be slower and less sudden than the current panic suggests. His case is that humans and AI will stay useful together for a long time, because real work has bottlenecks, demand grows when things get cheaper, and society adapts more slowly than models improve.

Not an engineering write-up so much as Steve Yegge in full storytelling mode, marking his own project reaching v1.0 with jokes, extended metaphors and a fair amount of victory lap. Gas Town orchestrates fleets of coding agents behind a “Mayor” abstraction, a conversational layer that summarises what the workers are doing instead of making you watch them, since ordinary coding agents “babble while they work”. His framing: if Claude Code is an executive assistant, the Mayor is more like a chief of staff.

The companion project is Beads, a memory and knowledge-graph system that stores work items as versioned structures you can query like a database. The pitch is that it captures the “why” that commit history loses: the planning, the reasoning and the audit trail across a project’s life.

Steve Yegge on maintaining two fast-growing open source projects, Beads and Gas Town, that between them take around 50 contributor PRs a day, roughly 99% of them AI-generated. His answer is not to filter harder but to accept nearly everything and put agents on the repair work. Over five months: 1,000+ contributors, 4,000+ PRs with 2,300+ merged, an 88% eventual merge rate, and a median resolution time of about 15 hours, at 15 to 20 hours a week of his own time.

The argument underneath is about what rejection now costs. Anyone turned away can have an agent fork the project and maintain the fork, so a No is no longer the end of a conversation:

Forking used to be a declaration of war. Now it’s simply a declaration that someone liked your software enough to want to change it, but you said No.

Matthew Binshtok, writing up an internal Vercel talk, on the gap between code that looks like an experienced engineer wrote it and code that knows anything about your production environment. Agent output clears review because it reads well and the tests are green, but it has no view of load, of what fails at 3am, or of the assumptions your infrastructure quietly depends on. His compression of the problem:

Green CI is no longer proof of safety.

Rex Lin and Valeria Verzi at Klarna, with Anant Nawalgaria at Google, on using AlphaEvolve to optimise the training pipeline behind their models rather than prompting an assistant to do it. The setup is a search loop: engineers fence off which code may change, name the metric, and fix the constraints that must hold, then the system writes candidate programs, runs them, scores them, and breeds from the survivors. Nearly 6,000 candidates over three weeks, with no human reviewing individual outputs.

Throughput went from 49 samples per second to roughly 72 in the mixed-precision phase, and to about 97 once run under deterministic constraints, hence the doubling in the title. Determinism was not optional here: if you can’t reproduce the exact result, you can’t audit it, and you can’t deploy it in regulated financial services, so the constraint was built into the fitness function rather than checked afterwards.

Anthony Shew on eight days of optimising Turborepo’s Rust codebase with background agents, and what the humans in the loop were actually for. The measured thing throughout is Time to First Task, the task graph computation Turborepo does before it starts running any of your work, not build time. Between v2.8.0 and v2.9.0 that dropped from 8.1 seconds to 716 milliseconds on Vercel’s largest monorepo of around 1,000 packages, which is 91% faster. Smaller repositories gained less: 81% at 132 packages, 80% at six.

The 96% in the title is a ceiling rather than a result. Testing against open source repositories and customer canaries, Shew found improvement could get as high as 96% depending on the size and complexity of the repository. Worth holding the baseline in mind before repeating the number.

Computers required complementary investments that took years or decades to develop: new business processes, organisational restructuring, worker retraining, new management practices. It took until the 90s to see any macroeconomic productivity impact

Annie Vella on a Thoughtworks retreat about the future of AI-driven software development. People are starting to name the questions around cognitive load, trust, platform foundations, agent governance, and the changing shape of engineering work. The key lesson for her was “Nobody has this figured out”

A nice description of the anatomy of a harness with the memorable formula Agent = Model + Harness

Christoph Hamsen, Kylian Serrania and Christophe Tafani-Dereeper on catching an attacker who was using an LLM to scale up malicious open source contributions. Their framing of why they answered in kind:

Malicious actors are adopting LLMs to guide and scale their operations, and we as defenders must also use them to keep pace.

The tool is BewAIre. It watches GitHub events, picks the security-relevant ones, extracts and normalises the diff, enriches it with context, and passes it to a two-stage LLM pipeline that calls the change benign or malicious with a written rationale. Malicious verdicts go to Cloud SIEM as signals for triage. The volume it exists to handle is close to 10,000 pull requests a week.

Alp Keles, Jai Menon, Sesh Nalla and Vyom Shah on what to do when agents write code faster than anyone can read it. Their answer is to stop treating review as the place correctness comes from:

With a harness, code reviews become bloom filters: a fast gate, not the source of correctness.

The harness is a stack of automated checks rather than a single technique. A shadow-state oracle runs a plain HashMap alongside the real executor and compares after every operation. Deterministic simulation testing abstracts away real time and injects faults, at roughly five seconds a seed. Then TLA+ specifications, model checking with Stateright, bounded proofs with Kani, Maelstrom with a linearizability checker, property-based testing, shadow deployment against real traffic, and production telemetry to close the loop. The argument for this ordering is that formal methods used to be too slow to be worth it, and cheap agent labour inverts that.

Ramp’s security team makes the case for building your own security agents rather than buying them, on the grounds that you already know how to find, validate and fix vulnerabilities in your own environment, and a home-grown team of agents fits your specific environment, priorities, and threat model better than anything on the market today.

The pipeline has five stages. A coordinator holds a skill per vulnerability class and launches detector agents in parallel, each a specialist in one class, briefed with a definition, the steps an analyst would take, the usual impact and real examples from the codebase. Manager agents then argue against what the detectors found. A validator writes an integration test that reproduces the issue and only passes if the endpoint is secure, which catches false positives the earlier stages let through. Finally a fixer works test-first against that test and opens a PR, where a human takes over to review and land it.

The Cognition team on running Devin against their own codebase, reached through whichever surface someone is already in: the web app, Slack, Linear or Jira tickets, the CLI and the API. The work they point it at is the high-volume iterative kind. Bug fixes and edge cases, test coverage, CI failures, lint errors and CVE remediation, PR review, documentation upkeep, codebase questions, and audits that run daily to catch design system violations from the previous 24 hours. Ask Devin gets used constantly to scope a piece of work before a session starts.

Simon Willison points to Margaret-Anne Storey’s useful framing of cognitive debt: the loss of shared understanding when AI helps teams move faster than they can explain. The code may work, but the team can still lose the plot.

Alistair Gray’s architecture follow-up to the first minions post, with the rate now at over 1,300 minion-produced PRs merged a week, up from 1,000 in Part 1. Little of the design is exotic. What makes it work is that each piece already existed for human developers.

Runs happen on devboxes, EC2 instances pre-provisioned so one is ready in about ten seconds. Stripe describes them in the usual DevOps terms: cattle, not pets, standardised and easy to replace rather than bespoke and long-lived. On top sits a fork of Block’s goose agent, running with full permissions inside that box. Orchestration comes from blueprints, which are workflows defined in code that mix deterministic nodes (lint, push) with agentic ones (implement the task, fix the CI failures). Context comes from Cursor-format rule files scoped to subdirectories and from Toolshed, now at nearly 500 MCP tools, with each agent given a curated subset so the tool list does not swamp the context.

Ryan Lopopolo on five months of building an internal OpenAI product under one constraint: zero manually-written lines of code. Everything, application logic, tests, CI config, documentation, observability and internal tooling, came from Codex. About a million lines and roughly 1,500 merged PRs, starting from an empty repository in late August 2025, with three engineers driving the agents. That works out at 3.5 PRs per engineer per day, and the rate went up rather than down as the team grew to seven. They estimate it took about a tenth of the time hand-writing it would have.

Harness engineering is the name for what the humans did instead of coding. The scarce resource is human time and attention, so the job becomes designing the environment the agent works in: humans steer, agents execute. When something failed, the response was not to prompt harder but to ask what capability was missing and make it legible and enforceable. Review has largely followed:

Humans may review pull requests, but aren’t required to. Over time, we’ve pushed almost all review effort towards being handled agent-to-agent.

Alistair Gray on why Stripe built its own unattended coding agents rather than adopting an off-the-shelf one. The argument is that general tools stall on a codebase this size and this unusual: most of Stripe’s backend is Ruby without Rails, typed with Sorbet, spread across a few large repositories. A minion is one-shot and end to end:

Over a thousand pull requests merged each week at Stripe are completely minion-produced, and while they’re human-reviewed, they contain no human-written code.

Engineers can start one from a CLI or a web interface, but usually do it from Slack. From there it runs unattended in a pre-warmed devbox, gathers context through Toolshed, an internal MCP server with more than 400 tools covering internal systems and the SaaS products Stripe uses, lints locally for fast feedback, then pushes and iterates against CI, which selects from a battery of over three million tests. What lands is a branch and a PR for a human to review.

Eric Dodds and Allen Zhou on extending brand tracking to a channel that does not behave like a chatbot. Vercel already runs what it calls an AI Engine Optimization system, tracking how models discover, interpret and reference Vercel and its sites. Coding agents needed a separate harness, because developers meet them in a terminal or IDE partway through real work rather than by asking a question cold. Their reason for caring:

Agent recommendations have a different shape than model responses. When a coding agent suggests a tool, it tends to produce working code with that tool, like an import statement, a config file, or a deployment script.

David Crawshaw’s follow-up to Programming with Agents, written eight months later. The change he measures is in what he spends his time on rather than in the tooling: at a big company his split was 80-20 reading code to writing it, at a startup nearer 50-50, and now it is 95-5. The model does the writing. A year ago Claude Code could write a quarter of his code; in February the latest Opus model writes nine tenths of it.

His flat claim about where the progress came from:

Agent harnesses have not improved much since then. Right now, it is all about the model.

Dan Shapiro’s scale for AI coding automation: level 1 offloads small tasks, level 2 pairs with an AI-native coding tool, level 3 manages agents through diffs, level 4 delegates from specs and plans, and level 5 is the dark factory where specs go in and software comes out.

Nicholas Carlini set 16 agents working on a shared codebase to write a C compiler in Rust, with no active human intervention while they ran. The result is a 100,000-line compiler that builds the Linux 6.9 kernel, QEMU, FFmpeg, SQLite, PostgreSQL, Redis and Doom, targeting x86, ARM and RISC-V, with a 99% pass rate on most compiler test suites including the GCC torture tests.

The costs are worth recording alongside that. Nearly 2,000 Claude Code sessions across two weeks, just under $20,000, with Opus 4.6 consuming 2 billion input tokens and generating 140 million output tokens.

David Heinemeier Hansson’s bet is that agents will end up using the interfaces built for people, rather than needing purpose-built ones. His analogy:

if I was going to skate to where the puck is going to be, it’d be a world where agents, like self-driving cars, don’t need special equipment, like LIDAR or MCPs, to interact with the environment

To test it he gave an agent called Kef no skills, MCPs or APIs, and ran it on a Proxmox virtual machine isolated from his own logins and data. From simple prompts it signed up for HEY email, created a Fizzy account, built a board of five business ideas with images it found on the web, and accepted a Basecamp invitation that arrived by email. He reports zero corrections. He ran it first on Claude Opus 4.5, then repeated most of it on the Chinese open-weight model Kimi K2.5.

Mitchell Hashimoto walks through his own adoption in six named phases: drop the chatbot, reproduce your own work, end-of-day agents, outsource the slam dunks, engineer the harness, and always have an agent running. The framing is that each phase was uncomfortable before it was useful, and that the early ones felt like a cost rather than a gain. On reproducing work he already knew how to do:

This was excruciating, because it got in the way of simply getting things done.

He is careful not to oversell the later stages. Background agents running continuously are, by his estimate, effective 10 to 20% of the time, which is worth it only because the attempts are cheap and run while he does something else. He also budgets a fixed daily slot, around 30 minutes, for setting up end-of-day runs.

OpenAI’s account of turning an internal convenience into a public protocol. The App Server began as a way to reuse the Codex harness in the VS Code extension without reimplementing the agent loop, so it was never designed as a stable API. Demand from internal teams and partners changed that: JetBrains and Xcode wanted an IDE-grade agent, and the desktop app needed to run many agents in parallel.

The design problem is that agent work is not request/response. One user input unfolds into a sequence of actions the client has to render faithfully, so the protocol settles on three primitives. An item is the atomic unit of input or output, typed and with an explicit started / delta / completed lifecycle so clients can paint as content streams. A turn is one unit of agent work started by a user input. A thread is the durable container of turns, and can be created, resumed, forked and archived.

Angie Jones, who leads AI enablement for engineering at Block, on how you get an organisation from curiosity to habit. The strategy is tool freedom rather than a mandate: engineers pick from Claude Code, Goose, Cursor, Copilot and others, and 95% of them now use AI regularly. Progress is tracked as stages, with the largest group running a single agent outside the IDE and the next largest running three to five agents in parallel.

The lever was an AI Champions programme: 50 developers drawn from Block, Square, Cash App, Afterpay, Tidal and platform teams, each given 30% of their time for enablement work. Within three months AI-authored code rose 69%, reported time savings rose 37%, and automated pull requests went up 21 times.

A short piece of prompting advice from Brian Lovin, built around one rule:

You must give your agent the ability to view and verify its own work.

His test for whether you have done that is blunt. If the agent ever asks you to do something manually, stop and work out how to give it the tools to do that itself. Vague instructions like make it faster or find bugs fail because the agent has no way to tell whether it succeeded, so it works briefly, keeps asking you to check, or fixes one thing and breaks another.

Thomas Ptacek’s framing for Fly.io’s new Sprites is cheapness of use rather than raw power:

Sprites are ball-point disposable computers.

The point is that you stop rationing them. Creation takes a second or two, so shelling into a fresh one feels the same as SSH’ing into a machine that already exists, and he admits he barely bothers naming them.

Zach Bruggeman, Jason Quense and Rahul Sengottuvelu on Inspect, the background coding agent Ramp built in-house. The point they keep returning to is verification: Inspect writes code like any other agent, but it also has the context and tools to prove the code works. On the backend that means running tests, reading telemetry and querying feature flags; on the frontend it means screenshots and live previews. Their line for it:

Agents should have agency, and so we made sure Inspect is never limited by missing context or tools, but only by model intelligence itself.

Each session gets a sandboxed VM on Modal with a full local-equivalent dev environment, wired into Sentry, Datadog, LaunchDarkly, Braintrust, GitHub, Slack and Buildkite. Repository images rebuild every 30 minutes and sessions restore from a snapshot, so a checkout is at most half an hour stale and startup is close to instant. Sessions are cheap enough to run several against the same prompt and pick the winner. About 30% of pull requests merged to their frontend and backend repos are now written by Inspect, reached in a couple of months without anyone being told to use it.

David Heinemeier Hansson’s account of changing his mind. He never liked in-editor autocomplete, the format Copilot and Cursor started, because he wants to finish his own sentences. Autonomous agents in a terminal harness feel different to him, less like a pair programmer stealing the keyboard and more like working with a team: they run the tests, search for documentation and use services through skills written in plain English, and he reviews the outcome. The change, he says, is less about the models improving than about giving them tools that take them past pure reasoning.

The promotion in the title is that agents now produce production-grade contributions to real codebases rather than just helping him learn or checking his work. He is careful about how far that goes. Pure vibe coding is still aspirational for professional work; supervised collaboration is what is available today.

Max Leiter on the three parts of v0’s pipeline that did most for reliability. The metric Vercel optimises for is the share of generations that produce a working site in the preview rather than an error or a blank screen, and Leiter says code from an LLM running on its own can have errors as often as 10% of the time. Catching and repairing those during streaming is worth a double-digit increase in success rates.

The three parts are a dynamic system prompt, a streaming layer they call LLM Suspense, and a set of autofixers. The system prompt injects knowledge about the current AI SDK version when the model’s training data would otherwise be stale, which they prefer to web search because a small model summarising search results turns into a game of telephone. LLM Suspense rewrites text as it streams, so the user never sees a wrong intermediate state: swapping long blob URLs for short ones to save tokens, and fixing hallucinated lucide-react icon names by embedding every real icon name in a vector database and substituting the nearest match, in under 100 milliseconds and with no extra model call. The autofixers run after streaming for problems that need the AST or span several files, and complete in under 250 milliseconds.