IssuesAllIssue 08 · 8 NovIssue 07 · 24 OctIssue 06 · 10 OctIssue 05 · 27 SepIssue 04 · 11 MayIssue 03 · 3 MayIssue 02 · 29 AprIssue 01 · 17 Apr
Rx Perspective

The Next Bottleneck Is Not Code

Issue 08 · A perspective by Jack Wang · Issued 8 Nov 2026·18 min read

In the first week of November, HumanLayer joined Factory, and Cursor let anyone in an organisation build and publish live apps. Weeks earlier, at OpenAI’s DevDay, its models had helped tune the software that runs them. Follow one digital team’s Friday through three stages of what AI SDLC may mean for you.

Audio edition · The Next Bottleneck Is Not Code
0:008:55
// topic · AI SDLC

AI made code nearly free. The bottleneck moves to judging it, choosing what runs, and deciding who may act.

depth 00

Coding agents can now draft most changes in minutes. What that means for the teams who ship software is easier to show than to explain, so here is a Friday most digital teams will recognise.

Friday, ten past nine. The weekend offer went live an hour ago, and the small digital team that owns it, from the app to checkout to the portal suppliers use, is already behind.

A thirty-second video about the offer is spreading. The marketing lead wants a landing page and an app notification out before lunch, while people are still paying attention. Then a supplier withdraws one of the products featured in the video. Customer service forwards a complaint from a customer whose discount vanished at checkout. It runs to two pages and sets out their rights in confident legal language, clearly written with an AI assistant’s help. The chatbot, meanwhile, is telling other customers they qualify.

At half past ten, the security lead forwards an advisory. PHP has patched two critical flaws that let an attacker run code on a web server without logging in. The UK’s National Cyber Security Centre is blunt: find every affected installation, update it, and consider taking offline anything that cannot be protected in time.

Checkout runs on PHP. Marketing wants more traffic through it this afternoon. Security may need to switch it off.

Figure 1 · Illustration

Friday morning, as it lands

One team’s channel between ten past nine and half past ten. The team and its messages are illustrative. The advisory is real.

Digital team
M
Marketing09:10

The offer video is spreading. Landing page and app notification before lunch?

S
Supplier portal09:24

A featured product has been withdrawn from the promotion.

C
Customer service09:41

Two-page complaint: discount vanished at checkout. Cites their rights.

C
Chatbot09:52

Telling customers who ask that they qualify.

S
Security10:30

Critical PHP flaws, no login needed. NCSC: patch, or take it offline. Checkout runs on PHP.

Checkout, this afternoon
M
MarketingMore traffic through checkout this afternoon.
S
SecurityCheckout may need to come offline.
Message the team
10:30
Friday
10:30
SSecuritynowCritical PHP flaws, no login needed. NCSC: patch, or take it offline. Checkout runs on PHP.
  1. 09:10, Marketing: The offer video is spreading. Landing page and app notification before lunch?
  2. 09:24, Supplier portal: A featured product has been withdrawn from the promotion.
  3. 09:41, Customer service: Two-page complaint: discount vanished at checkout. Cites their rights.
  4. 09:52, Chatbot: Telling customers who ask that they qualify.
  5. 10:30, Security: Critical PHP flaws, no login needed. NCSC: patch, or take it offline. Checkout runs on PHP.
  6. The clash. Marketing asks: More traffic through checkout this afternoon. Security warns: Checkout may need to come offline.

The team has coding agents. The landing page, the eligibility fix, the chatbot’s answer and the patch could each be drafted before eleven. Drafting is not the hard part. The hard part is deciding which change is right, checking it, and agreeing who may stop what, while everything moves at once. Most teams using AI are now stuck exactly there.

So what does AI actually solve for them?

depth 01

Three stages

Building used to be the scarce part, and the way teams plan, review and release was designed to ration it.

Engineers were scarce, and coding, testing and shipping took weeks if not months. AI ends that scarcity. What it solves after that depends on how far a team is willing to change. Most enterprise teams are starting to live in the first stage. The second is arriving for the teams a little ahead, and the third is being built now.

A lane is one stream of work, such as the landing page or the patch, carried from request to release. The first stage runs one lane at a time; the second runs many at once.

The three stages compared. The last row is a self-check: pick the line that sounds like your team.
The single-lane factoryThe multi-lane control towerThe recursive loop
What AI doesDrafts every changeRuns many changes at once, under shared rulesLets customers, partners and their agents build on what you ship
Where it jamsOne engineer’s review queueChoosing which work deserves to runTrust: who and what may act, within which limits
Who changes mostEngineers: from checking agents to teaching themProduct: from one roadmap to many lanesArchitects: hold the rules fixed, free everything else
This FridayThe PHP patch waits behind four other changes for the same reviewerAgents find and test the fix everywhere checkout runs; security decides by noon, with evidenceThe complaint is never written: their assistant checks eligibility and gets a receipt
You are here ifPick one

Pick the line that sounds most like your team.

Each stage feeds the next, and each round starts from a better place than the last.

Figure 2 · How the stages feed each other

Each round starts higher than the last

What each role learns becomes what the next one builds on. It plays round and round; tap a role to hold it there, and tap it again to let it move on.

A loop of four roles. Each passes something to the next, and the return to engineering lands one level higher than where the loop began.
  1. Engineering teaches the factory to build to its standardPasses on rules
  2. Product uses those rules to run many lanes, and learns what is worth buildingPasses on rules that survive
  3. Architecture turns the rules that survive into a scaffold others build onPasses on the scaffold
  4. Customers build on the scaffold, and what they build becomes evidencePasses on evidence
which starts engineering’s next round, from a better place than the last

AI will make more of the decisions, within the policies people set. It works the way people naturally work, through requests, explanations, disagreements and decisions. Along the way, it captures what used to leave the room with them: the context behind every request, the reasoning behind every call, and what happened next. That record compounds with every change, and no competitor can simply copy it.

Efficiency is what AI does for a team. Intelligence is what it leaves behind.
depth 02

The single-lane factory

AI accelerates the build, but people keep the habits built for scarcity, and their attention becomes the bottleneck.

On a Friday like that one, the senior engineer has five agent-written changes waiting for them, each built on assumptions they never saw. The urgent security patch is one of them.

This month, LinearB launched a product for steering coding agents, and its own benchmark report describes the first stage precisely. Its data covers more than eight million pull requests, the proposed changes engineers submit for review, and its survey finds almost nine in ten organisations using AI tools every week. Yet changes written with AI were merged within a month only about a third of the time, against more than four in five for work written without it. Changes opened by agents waited about five times longer for someone to pick them up.

Nearly half of organisations do not formally measure AI’s impact, while three-quarters of leaders report productivity gains, on the strength of adoption figures, not delivery data. LinearB’s explanation is largely human: nobody clearly owns an agent’s work, and reviewers hesitate over large or complex changes.

Writing got cheap. Judging did not.

It would be easy to read those numbers as proof that AI is not helping. They describe the general population: teams that added agents to a process built for people to read every line. At the frontier, the same models produce a very different picture. Lauren Tan, then at Cursor, says she shipped more than 2,000 pull requests to production in a single month this summer, most of them written by her agents. Her own diagnosis is blunt: “I’m the bottleneck, and I need to move what engineers know into this set of agents.” The models are available to everyone. What differs is where human attention goes.

Figure 3 · Same agents, different bottleneck

The queue is human

Most AI-written changes in the general population do not ship within a month. At the frontier, one engineer who moved her attention from reading code to designing checks merged about 500 times as many. Watch one month play out, one dot for each merged pull request.

The general population

Of every 100 changes opened, how many shipped within 30 days?

The general population. Of every 100 changes opened, how many shipped within 30 days?
ChangeMerged within 30 days
Written without AI84.4%
Written with AI32.7%

Source: LinearB, 2026 Software Engineering Benchmarks Report, 8.1 million pull requests from 4,800 teams. LinearB notes these relationships are correlational.

The frontier, against the baseline

Same models, one month. How many pull requests did each person merge?

Day30of 30

  1. A typical developer the middle band of 4,800 teams

    : about 4 merged in the month.

    Source for A typical developer: LinearB 2026 benchmarks
  2. A top-10% team per developer

    : about 9 merged in the month.

    Source for A top-10% team: LinearB 2026 benchmarks
  3. Lauren Tan then at Cursor, August 2026

    : more than 2,000 merged in the month, about 500 times the typical developer.

    Source for Lauren Tan: her post and talk

Merged pull requests in one month, per person. The first two rows are the baseline, the last two the frontier.
WhoMerged pull requests in the monthTimes the typical developerSource
A typical developer, the middle band of 4,800 teamsabout 4baselineLinearB 2026 benchmarks
A top-10% team, per developerabout 9baselineLinearB 2026 benchmarks
Lauren Tan, then at Cursor, August 20262,000 to 2,500about 500 timesher post and talk
The frontier figure is self-reported by one engineer working with a fleet of agents. The baseline is a team average from LinearB’s 2026 benchmarks (8.1 million pull requests, 4,800 teams). Lauren Tan’s post says 2,500; the slide in her talk says 2,000.

None of this would surprise the people who spent 2025 on the unglamorous problem of keeping agents on track. In August 2025, heavily influenced by HumanLayer’s 12-Factor Agents and Sean Grove’s case for specifications as the carrier of intent, I described the same shift from inside the enterprise. Engineers would move from writing code to architecting intent, and checking AI output would become the new core skill. Late in 2025, the models caught up with the method. Adoption was already rising. Most ways of working did not change.

That is the trap of the first stage. A team can count adoption and see nothing but progress while its reviewers drown and its releases slow. The measures that matter sit after the build: how long work waits for a person, how often it comes back, and how much of it ever ships. If people still write every instruction and read every line, the team has bought a faster engine for the same queue.

The engineers furthest ahead have found the way out. Mitchell Hashimoto, who maintains the Ghostty terminal, turns each agent failure he catches into a line in the project’s instructions for agents, or into a tool, so that it does not repeat. Vercel’s AI SDK team sorts every run that does not ship by cause. A flawed result needs better context or a new test. A blocked one needs a missing credential. A deliberately manual step prompts a fresh look at whether that boundary is still needed. Each fix lets the factory take on work it could not be trusted with before. At Vercel’s Ship conference in San Francisco, Shopify’s Tobi Lütke said his engineers now think of themselves as verification engineers, building the tests that prove a change does what it should. The craft has moved up a level, into the instructions and checks that hold agents to an engineer’s standard when the engineer is not in the room.

For the digital team, the telling number is how long each of Friday’s five changes sat waiting for one engineer or a sign-off from governance. The fix is for the engineer to turn their caution into checks the agents run, and for governance to turn its approvals into policies they run, so that next Friday’s changes arrive already meeting both standards.

Their new question: how do I teach the factory to get it right without me?

depth 03

The multi-lane control tower

AI takes on the load and ships many lanes at once, while people set the policies, priorities and limits.

Go back to the security advisory that landed on that Friday morning.

Late in October, the agent company Factory published an account of the PHP response that showed what the second stage looks like for exactly this advisory. An advisory can trigger agents that find every affected repository, prepare and test the fix, and run a two-pass security review before an owner merges it. Its point was that a security team can confirm a risk in an afternoon and still wait weeks for dozens of repositories to ship the fix, and that this gap is where most of the exposure lives. A response that depends on one person chasing every owner cannot keep up.

The machinery a team once built for each lane is becoming something it can rent. OpenAI’s new Agents API offers its own agent harness, the loop of tools and checks around a model, as a managed service, and with Claude Managed Agents on Vercel, Anthropic runs the agent loop while every command executes in a sandbox the customer owns.

The control that makes this safe is taking shape just as quickly. Facing more than a thousand open issues in the summer, Vercel’s AI SDK team had built its factory around the reviewer rather than the coder. Specialised agents classify, reproduce, implement and review. Each change arrives with a chain of evidence, review depth follows risk, and every agent runs in a sandbox holding only the secrets its task needs. A person still approves every merge. On the London stage in June, Cursor’s Arthur Viegers said autonomy should track risk, citing Shopify and Amplitude, which already auto-review and merge 60 to 70 per cent of low-risk changes while a two-line change to authentication still goes to a person. Anthropic’s André Balleyguier suggested judging each agent action by how reversible it is and how far its damage could spread.

Running many lanes at once revives everything the old process was built to avoid: changes colliding in shared code, one rule copied into five places, refactors that cannot wait for a quiet quarter. Fixed release dates and change freezes existed because coordination and rework were expensive. Coordination and rework are cheap now, as long as coordination runs at the speed of building. That puts AI at the centre of it, mapping what each change touches, flagging collisions before they merge, and holding every lane to the same guardrails.

On a Friday like theirs, the security lead decides with the evidence in front of them instead of the team guessing under pressure. Five lanes ship before lunch without colliding, and the chatbot and checkout finally agree because they share one offer rule.

Anthropic shows what coordination at the speed of building means at scale. Its merged code changes rose from about 2,500 a day in May to more than 30,000 a day by September, and git, the system almost every software team uses to track changes, could not keep up, so a team of seven built a replacement.

Figure 4 · When the factory outgrew git

From about 2,500 merged changes a day to more than 30,000

Anthropic’s merged code changes per day, May and September 2026. One day plays out at each rate. Git was built for human scale; a team of seven replaced it with Scion in five months.

Merged changes in a day, on one scale

  1. May 2026 on git

    about 2,500 a day

    Git could not keep up. A team of seven replaced it with Scion in five months.

  2. September 2026 on Scion

    more than 30,000 a day

About 12× as many changes a day

“Our team members still review every change request … they now examine the intent of the change as opposed to reading every line of code.”

Anthropic

Anthropic’s merged code changes per day, and the source control each day ran on.
MonthSource controlMerged changes a day
May 2026gitabout 2,500 a day
September 2026Scionmore than 30,000 a day
Source: Anthropic, “Redesigning source control”, 13 October 2026. Anthropic gives the two daily averages and the migration; the animation does not show the months in between.

Rebuilt plumbing is only half of a control tower. The other half is deciding what flows through it, and that is where the product job changes most. Anthropic’s Mike Krieger has described arguing that Claude could cover the product manager’s role, then discovering how much coordination the role still supplied: customers, safeguards and support readiness all needed an owner. The teams further along are rebuilding that coordination as a system. At Vercel’s New York event, Serhant, the New York property firm, described agents that mirror a software team. Product agents write requirements, engineering agents turn them into specifications and build agents take them from there, so its engineers now lead several streams at once.

Even complaints become signals for the next lane. The Legal Ombudsman’s research found that AI helps people put a concern into words but can also add legalistic or inaccurate material. The right response to a machine-written complaint is an investigation of what happened, and a lesson for the next brief, rather than a longer machine-written reply.

In the first week of November, Factory took in HumanLayer, the small team that spent 2025 engineering the context around coding agents and showed much of the industry how to work with them. Factory describes its product as a governed, model-independent system that turns business priorities into production software, with every workstream learning from measured results. The written intent that a few of us were arguing for in 2025 is becoming the place where teams meet.

It is also where the product manager now works: deciding which lanes run, in what order, and when to stop, and settling disputed ideas with small tests on real customers.

depth 04

The recursive loop

The product a team ships becomes a set of building blocks that customers, partners and their agents finish.

Go back to the customer whose discount vanished at checkout, and who sent two pages of legal language about it. At the third stage, those two pages would never have been written. The customer’s own assistant would have checked their eligibility and come back with a receipt.

Figure 5 · Illustration

The complaint that is never written

The customer’s own assistant calls the retailer’s business actions, check eligibility and apply offer, and comes back with a receipt. The interface it builds serves them once and is never shipped. The actions underneath stay.

Business actions
10:02Apply offerCustomer’s assistantApplied
10:02Check eligibilityCustomer’s assistantEligible
10:02
Assistant
Built for you · this moment
Large textPlain EnglishTo my card
EligibleApplied

You’re owed £12.40.It’s back on your card.

WKD-20481 · Reversible until Sunday

Not shipped. The actions remain.

Not shipped. The actions remain.

Message
  1. The customer tells their own assistant: “My weekend discount didn’t come off at checkout.” They start to write: “Formal complaint…”
  2. The assistant replies: “Before you send that, let me check.” The draft goes.
  3. It builds a panel for them alone, marked “Built for you · this moment” and shaped by their settings: Large text, Plain English, To my card.
  4. It calls the retailer’s “check eligibility” action for Weekend offer: eligible. The retailer’s business actions log records the call from the customer’s assistant.
  5. It calls the retailer’s “apply offer” action for Saturday’s order: applied. The retailer’s business actions log records the call from the customer’s assistant.
  6. The panel answers in one plain line: “You’re owed £12.40. It’s back on your card.” Reference WKD-20481, reversible until Sunday.
  7. The panel dissolves: “Not shipped. The actions remain.” The log keeps both calls.

The clearest early example of this stage arrived in October, inside a product many people already use every day. Anthropic released mods for Claude Code, which also runs in the Claude desktop app. In plain terms, a mod lets anyone reshape the standard Claude app into the tool they actually want: change what Claude is asked, stop or redirect what it does, and redraw what appears on screen. Most people will not write one. They will ask Claude to build it, then share it with colleagues to install. In principle, the same Claude app could become a mini Salesforce for the sales team, a mini Workday for HR or a mini SAP for finance, each looking and behaving the way that team works. Claude Code’s creator, Boris Cherny, put the thinking simply: people work differently, so there is no reason for everyone to have the same Claude. Anthropic already builds some of its own features this way. What stays fixed is just as telling. In company settings, Anthropic’s own security guard loads first, and by default no mod can override the organisation’s rules on what is off limits.

A month later, Cursor took the same idea beyond developers’ own tools. Anyone in an organisation can now describe an app, have it built with a database, sign-in and hosting, and publish it to colleagues. Security checks run first, nothing goes live without an explicit publish, and administrators can see every app and secret. Software can be built for one person’s way of working, and governance has to move into the platform to keep up.

The same shift is reaching customers. In May, Google began rebuilding Search around generative interfaces that can assemble a custom tool for a question. Weeks earlier, Y Combinator had asked founders for “dynamic software interfaces”, arguing that software companies will soon ship shared building blocks and expect users to customise the final product themselves. One of its summer companies, Vendo, already embeds an agent inside other companies’ products, so each customer can build features and small apps on top, using the product’s own API and inside the guardrails the vendor sets. On Vercel’s stages this year, Currys described moving its storefronts towards shopping agents, where customer intent replaces navigation. These are early and uneven signals, but they point the same way: towards products with a customer count of one.

For the digital team’s architect, every one of these examples answers the same question: what must stay fixed so that every customer can build the rest? In each case the answer is a scaffold that others complete.

The scaffold holds what must never vary: the business rules, the permissions and the record of every action, kept inside systems the business owns, with every channel and agent going through them. Everything above it, including the AI models, is replaceable, so the same scaffold can be repeated across thousands of customers.

depth 05

The direction of travel

Put the pieces from all three stages together and rebuilding stops being an event.

For most of software’s history, rebuilding was the most expensive thing a team could do, so evidence that a product had stopped fitting its customers waited for the next big programme. When the factory can refactor, rebuild and reship continuously, that evidence can be acted on as it arrives, often before anyone files a request. Routine rebuilds go ahead within policy. People decide the ones that change what customers see or are promised.

It is tempting to read all of this as news from a handful of very large companies, years away from an ordinary enterprise. That misreads how the pace is set. The models, coding tools and platforms most teams already use come from these same companies, so their pace becomes everyone’s pace within months. And each improvement now feeds the next: models help optimise their own harnesses, factories improve the factories, and mods are built by the agent they modify. That is why progress here compounds rather than adds. A team can bet that it will never move this fast, or it can take the time to understand the loops driving it and bet with them. I know which bet I am making.

Constant rebuilding, and a different product for every customer, are only safe if something does not move. The scaffold is the business itself: actions such as checking eligibility, applying an offer or opening a complaint case, each with explicit permissions, limits, receipts and a way to reverse mistakes. The same actions can then serve colleagues, partners and customers’ own agents. Whatever they cannot handle flows back into the factory. The bottleneck leaves the team altogether and settles on trust: who and what may act, within which limits, leaving which evidence.

Today, the digital team’s problems are small enough to name. The offer rule lives in several places, so the chatbot and checkout disagree. A supplier withdraws a product and nothing tells the other channels. A complaint arrives with no case to anchor an investigation. These are problems of a handful of changes, channels and people, and the team fights them by hand.

At the third stage, the same team faces a different order of problem. Every customer sees an interface arranged for them, and many never see one at all, because their own agents query the catalogue and apply offers directly. The team’s agents work the supply side with suppliers’ agents, adjusting stock and promotions as availability changes. All of it runs on one platform, where the offer rule, the eligibility check and the complaint case each live once, and every interaction flows back as evidence. The problem becomes keeping millions of tailored interfaces, agent conversations and supplier adjustments consistent and safe, at a speed no person could follow. So the team stops chasing individual problems and steers the loops. The engineer’s checks keep the scaffold correct, the product manager’s lanes decide what changes next, and the architect keeps every channel, partner and agent building on it rather than around it.

back to depth 00

What is your next bottleneck?

Back on an ordinary Friday, the more useful question is what stands between a team and its next stage. Rarely a tool. Usually it is how people work, and the factory is the means of changing that. It moves every person up a level and gives them a collaborator that carries context across marketing, product, engineering and security, so everyone works from a clearer view of what was intended. Using it well means thinking differently about your own work, which is harder than adopting any tool.

Nobody is an expert at this yet. Even the teams furthest ahead rebuild their factories constantly and treat improving the factory as the job itself. Every role is starting from the same line, including the most experienced engineer in the room. That is the reason to start boldly rather than wait for a playbook: the only way to get good at this is to do it, and the teams that start first will learn first. The pressures that opened this piece will not wait either. Flaws are found at machine scale, complaints arrive written by machines, and attention moves in hours. A team can choose how deliberately it moves through these stages. It cannot choose to stay where it is.

The models will keep improving for everyone, so efficiency will spread. What a team learns through its own loops will not, and that is the only advantage worth building.

Every stage clears one bottleneck and reveals the next

  1. Writing the code (cleared)Cleared by agents that draft every change. This is what makes a factory possible.
  2. Reading every line (cleared)Cleared by mastering Stage 1: The single-lane factory
  3. Choosing what deserves to run (cleared)Cleared by mastering Stage 2: The multi-lane control tower
  4. Trust: who and what may act, within which limits (cleared)Cleared by mastering Stage 3: The recursive loop
  5. Where are you on this trail? And how quickly will you move, when the pace is set by loops that compound whether or not you join them?
Recommended listening

Guillermo Rauch on Delphi’s The Library of Minds is a useful companion, particularly the discussion of verification from 33:45 and of allocating compute from 37:05. Those are the decisions the team and its agents increasingly share.

Further reading. On the first stage: Simon Willison’s notes on the November 2025 inflection. On the second: OpenAI’s DevDay 2026 recap, including the Codex cloud security service that scans whole repositories and watches new commits; OpenAI’s kernel-security research pipeline, whose October run produced 2,308 candidate findings, of which it reproduced 1,724; and an OpenAI engineer on training Codex in the presence of its harness. On the third: Vercel’s Virtual Models, which make model choice centrally changeable and let teams evaluate a candidate before switching; OpenAI on tools, state and approvals as a separate layer around the model; and the Vercel Ship 2026 recap, where ZoomInfo said more than 40,000 of its customers build their own workflows inside its product, SAP described a design system that people and agents assemble from the same parts, Guillermo Rauch argued that production context turns software into a loop, and Tobi Lütke described Shopify rewriting its storefront renderer from Ruby to Rust and checking the output byte for byte before switching over.