When the bottleneck moves: why a 10x developer disappears inside a 1.1x organisation
AI makes developers produce more code and companies ship barely more software. Both are true, because coding was never the constraint of the whole. The constraint moved: first to review, then to the decision-makers. The gain shows up only when the process from idea to revenue is redesigned around them.
AI coding agents help developers produce more code, but that doesn’t always translate into proportionately more software shipped. Several major studies published in 2026 point to this gap:
- An NBER working paper covering more than 500,000 GitHub developers found an increase of 240% in commits with autonomous coding agents. The corresponding increase in releases was 30%.
- A Harvard study with Jellyfish across 655 firms found that, after coding agents were introduced, 36% more pull requests were opened and 26% more were merged, with no significant change in features shipped. The time from opening a pull request to merging it rose by 56%.
- Bain surveyed 293 technology leaders about the gains they see from AI in engineering and what they expect within the next one to two years. The reported median gains were 20% in developer productivity and 27% in release-cycle speed. Respondents expected those gains to rise by 95% and 148%, respectively.

So the disappointment is real. The “AI was supposed to make us 10x faster” story has been quietly downgraded to “we think we’re 10% faster, we can’t measure it, and the bugs are up”.
I think both sides of the story can be true at the same time. The reason was described as far back as 1984.
Why AI developer productivity gains disappear inside your process
I’ve watched experienced engineers who invested in their AI setup work at a pace I wouldn’t have believed possible two years ago. They’ve finished a client discovery call with a working prototype or left sprint planning with every story already implemented. I believe the 10x gain, or even more, is possible because I’ve seen it.
Public examples support that view, but they come with a catch.
- Peter Steinberger, founder of PSPDFKit and creator of OpenClaw, went from three public commits in 2024 to 69,000 contributions in 2025. All from “one dude sitting at home”, as he described himself.
- OpenAI’s Frontier team of three engineers produced roughly a million lines and merged 1,500 pull requests in five months, without a single handwritten line of code.
- Anthropic reports that an engineer now merges roughly eight times as many lines of code per day as during 2021–2024. It also cautions that this is “almost certainly an overstatement of the true productivity gain”.

The catch is that in each example, one person or a small team owned the full loop: idea, decision, specification, code, test, and merge. They didn’t have to wait for others at each step.
None of them reached that pace without investment. One OpenAI engineer says the first month and a half was ten times slower than working by hand, while the team built the environment the agents needed. Steinberger maintains an 800-line instruction file, which he calls “organisational scar tissue”, and spends a fifth of his time refactoring. Steve Yegge, who runs 40 agents around the clock on his own game, spends a quarter of his time maintaining the harness. At Anthropic, the number of standing instructions for agents grew from a few hundred to 8,500 in a year.
So the 10x gains can exist for experienced people who have prepared their environments and control the full loop. It just can’t survive a process built for the 1x. When that loop crosses an organisational boundary, the published multiples fall to between 1.2x and 2x. In Microsoft’s rollout of coding agents to tens of thousands of engineers, adopters merged 24% more pull requests, rising to 50% for daily users. That’s 1.24x, not 10x.
The question isn’t whether a 10x gain is possible, but where that gain goes.
Where the gains go: the constraint in your delivery process
Eliyahu Goldratt explored this question in his 1984 novel The Goal, where he set out the Theory of Constraints. His argument is that every system has a constraint, and the capacity of the system is the capacity of its bottlenecks.
Speeding up another part of the system can create more inventory without increasing output. As he put it: “an hour saved at a non-bottleneck is a mirage”.
Software delivery is a system too, and writing code is only one part of it. Bain estimates that writing and testing code account for 25%–35% of the time from initial idea to launch. Separately, an Atlassian engineering leader says developers spend about 16% of their time coding.
Take the generous number and do the arithmetic. A change takes 100 units of time, 30 of them for coding. If coding becomes ten times faster and everything else stays the same, the change takes 73 units: an overall speed-up of about 1.37x. Make coding infinitely fast, the change still takes 70 units. That’s the ceiling, 1.43x, whatever your developer’s multiple is. The other 70 units didn’t move.
That’s the whole paradox: a gain can be real at one stage without producing an equivalent gain across the whole system.
When you remove one constraint, another one takes its place. In The Goal, it moves from a machine to the heat-treat ovens and, finally, to the market. Published software examples from 2026 suggest a similar sequence.
First, the bottleneck moved to review. There is evidence for this: agentic pull requests wait five times longer to be picked up than human ones. Only a third of them are merged within 30 days against 84% for human work. The share of pull requests sent back with changes requested roughly doubled. Reviewers didn’t get slower. There are just more, and bigger changes than there are people to read them.
In the companies that fixed review, the constraint moved further upstream. In Marty Cagan’s words “the bottleneck is now much more appropriately recognized as, what do you want these people to build?”. Or Andrew Ng’s: “I don’t see product management work becoming faster at the same speed as engineering”. Figma’s VP of product engineering said AI “is shifting the bottlenecks upstream”, while Anthropic’s head of growth says the ratio of product managers to engineers “might need to flip”. So product and design work become the limiting factors, rather than coding.
None of those people has data to confirm the move. Neither do I, but I recognise the pattern from teams I’ve worked with. The sequence isn’t a rule: your constraint is wherever your work stops, and you find it by looking at your own process, not by assuming.
Faster software development increases the number of things you can build, but not the number of things worth building. That’s the main aspect that moved upstream.
How AI changes software team structure
Think about the teams many of us have built over the past 15 years: a product owner, an analyst, a tester, a scrum master or project manager, and four to six developers. Why so many developers? Because implementation was the largest block of hands-on work in the delivery chain, and it belonged to one role. Teams were staffed for the work they could see, not the waiting between activities. The shape of the team reflected where the constraint was.
Now developers are faster, but the questions that used to surface during a sprint still need answers. What should happen in an edge case? Which of two options does the business want? Those questions just now surface on Tuesday morning instead of in week two. The product owner, analyst, and business used to have two weeks to answer them, because the developers were busy. Now the developers are waiting.
What I see happening next is a reduction in the number of developers on a team. Four to six developers become one or two. Two, mostly so there’s another human to discuss the work with and review it. I don’t see a need for more in some cases, because two people working with agents can already deliver more change in a sprint than one brain can hold.
The cognitive load has shifted too: more context switches, responsibility for larger parts of an application, and code you didn’t write but still need to understand. Analysts and product owners face a similar challenge: they need to hold a coherent model of a system that now changes faster than anyone can read it, which is why their capacity doesn’t automatically scale with AI either.
I’m not alone in these observations. Instagram has moved from teams of around 13 specialists towards pods of four to six generalists, alongside a product role. Anthropic engineering managers say a project “often cannot have more than two people working on it”. Coinbase is experimenting with one-person teams. Cursor’s field CTO puts it this way: “two pizzas are too much pizza”.
Two developers working with agents can already produce more than a product owner working in the old way can absorb. Too many for one analyst, an old-fashioned QA approach, and a business that was never asked to make this many consequential decisions this fast. The constraint moved beyond engineering to the people who make those decisions.
In one case I saw, 90% of the implementation work was delivered on the morning of the sprint’s second day. The remaining 10% depended on a business decision. It took around a week and a half to get an answer; once it arrived, the team delivered the remaining work in hours. Everything was delivered and the sprint was closed. But was that a success? Or did the time the team gained with AI go to waste?
Five steps to fix AI software development bottlenecks
Look at your process honestly. Backlog refinement every two weeks, story-point estimates, sprints sized around what developers can build, a product owner who shows up to planning and review, and code review as the gate before anything ships. Many of these rules were established when developer time was scarce. They subordinate the whole company to the capacity of people who are no longer the constraint.
Here’s the frame I’d use:

That’s also where the edge lies now. AI multiplies knowledge. It doesn’t supply it. A company that understands its domain can use agents to help address questions, constraints, and decisions, reducing the time spent waiting at each stage.
That can include decision-making. An agent can turn an open question into two options supported by evidence. Where there’s a clear written rule, a team or an agent can make a reversible decision without waiting for further approval.
People remain accountable for irreversible decisions and their consequences. They also need to answer the first question: what’s worth building? That depends on what the organisation wants to achieve; no model can answer it on its behalf. Without that understanding, a company risks getting faster at building things it doesn’t understand.
Goldratt’s answer to a moved constraint is five steps, and they still work.
1. Identify it
Follow the queues. Count the questions waiting for answers, the pull requests waiting for human review, and the ideas waiting for decisions. Note how long each has been waiting.
2. Exploit it
The decision-maker’s hour is now the scarcest hour in the company, so it goes only to decisions that need them. Jeff Bezos’s old rule does most of the work here: “two-way door” decisions can be made by the team and written down. Consequential, “one-way door” decisions go to the business, prepared as a choice between two evidence-backed paths rather than an open question.
3. Subordinate everything else
Release work at the pace the business can decide, rather than the pace at which agents can generate. Limit the number of open decisions, not coding tasks, and favour small bets (because small bets need smaller decisions).
4. Elevate
Push reversible decisions down to the team that holds the context, give product teams their own AI tools for research and option-building, and train the business for tempo.
5. Go back to the start
Once you’ve addressed the constraint, look for the next one.

A few companies have put parts of this approach into practice. Zalando, using its own incident history, built a bot that scores every pull request by risk, and auto-approves the low-risk third; lead time fell by 20 to 40%. Intercom escalates any review that waits more than two hours, and its CTO says the bottlenecks have moved to decision-making and wait times. Shopify stopped counting lines and pull requests – they watch weekly demos and the reversion rate instead. Their own engineers name senior review of every merge as the bottleneck. None of the three examples reports what happened to revenue.
This is why I’d call it a product development lifecycle rather than a software development lifecycle. The process you’re redesigning doesn’t start with requirements or end at deployment. It starts with an idea and the business outcome it should affect. It continues until you can see whether people used what you built and whether it generated revenue.
Goldratt measured throughput in money generated through sales, never in features. If your lifecycle stops at deployment, you may miss a constraint that has moved to the market – as it does in his book and as it may in your organisation.
None of this is free, and it’s worth being clear about the cost. Business has to decide within hours, week after week, and treat most decisions as experiments rather than final verdicts. Implementation is cheap now, so a reversible decision tested this week beats a right one in six weeks.
Developers need to spend less time writing code by hand and take ownership of an environment in which agents can work. Building that environment may mean weeks of slower progress before it pays off.
The product owner’s work shifts from writing tickets towards defining hypotheses and acceptance criteria that a machine can check.
Specifications have a cost too; a small bug can turn into four user stories and sixteen acceptance criteria if you let it.
And whoever becomes the constraint – whether a reviewer or a product owner – can absorb pressure from the whole system unless the limits protect them.
What you gain from redesigning the process
You may not achieve a 10x across the whole chain this year. But the 10x in the implementation stage stops being a mirage and starts being throughput, because the rest of the system is, step by step, becoming able to receive it. That’s the only place the big number in AI developer productivity was ever going to come from. Not from a faster developer, but from a process redesigned around the new constraint, which may be the organisation’s capacity to make good decisions and act on them, rather than any individual person or role.
Technology changes the cost of activities. As costs change, constraints move. And when constraints move, roles need to move with them.
Where I stand: I’m Co-CEO of Spyrosoft Innovo, part of the Spyrosoft Group. We approach delivery as one process, from idea to revenue, not as coding with agents added on.
We help clients redesign that whole process, with AI built for every role at every stage – including analysts, product owners, reviewers, and business stakeholders – so they can address the points where the work really is waiting.
Key takeaways
- AI developer productivity gains are real at the coding stage: an NBER study found 240% more commits but only 30% more releases.
- Coding accounts for 25–35% of the time from idea to launch, so even instant coding caps the overall speed-up at about 1.43x.
- The bottleneck moves first to code review, then to the people who decide what to build.
- To realise the gains, redesign the process from idea to revenue around the new constraint.
FAQ: AI developer productivity
Because coding is only one part of delivery. Bain estimates that writing and testing code take 25–35% of the time from idea to launch, so even instant coding caps the overall speed-up at about 1.43x. The rest of the time goes to review, decisions, and waiting.
The first is code review: agentic pull requests wait five times longer to be picked up than human ones, and only around a third are merged within 30 days. Next come upstream decisions, such as what to build and which option the business wants. Your own bottleneck is wherever your work stops.
Bain estimates that writing and testing code account for 25–35% of the time from idea to launch. An Atlassian engineering leader says developers spend about 16% of their time coding. Even with the higher figure, a tenfold coding speed-up gives an overall gain of only about 1.37x.
Follow the queues. Count the questions waiting for answers, the pull requests waiting for review, and the ideas waiting for decisions, and note how long each has been waiting. Then apply the five steps of the Theory of Constraints: identify, exploit, subordinate, elevate, and repeat.
Yes, for experienced engineers who have prepared their environment and own the full loop from idea to merge. Once that loop crosses an organisational boundary, published multiples fall to between 1.2x and 2x.
arrow_circle_rightCONTACT US
Let’s discuss how we can help you with your projects
arrow_circle_right OUR ARTICLES