ai-dev

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.

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.

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.

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.

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.

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%.

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.

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.

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.

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.