Why AI-assisted development is slowing some R&D departments down, and what lean thinking says to do about it.
Over the last year or so, in conversations with engineering managers and in the published data, I have noticed something that looks, at first, like a contradiction. Manufacturing businesses have given their embedded software teams AI coding tools. The developers are producing working code much faster than before. And delivery from R&D has slowed down.
The pattern is not confined to any one business, and it is the pattern that matters. AI has not made anyone worse at anything. It has made one step of a long process much faster, and that step was never the one limiting delivery.
In a business that already had a good development pipeline, faster coding shows up as faster delivery. In a business that didn’t, the work that used to arrive at a manageable rate now arrives in a flood at whatever was already the slowest part of the process: manual acceptance testing, a product decision, a stage gate, hardware that isn’t ready, a DevOps team with a queue of its own. That part clogs, and throughput falls. Some of the flood runs backwards: developers pulling work through faster need decisions faster, and a question that used to come once a week now comes every day.

None of this is new knowledge. Manufacturing worked it out decades ago, and Mary and Tom Poppendieck translated it for software more than twenty years ago. What follows is the theory, the manufacturing history, the evidence now emerging from software, and what I think businesses should do.
The theory, briefly
Three old ideas explain what I am seeing.
The theory of constraints. Eliyahu Goldratt’s 1984 novel The Goal made the point that every system has a constraint, and the output of the whole system is the output of that constraint. His character Jonah turns it into a rule: an hour lost at a bottleneck is an hour lost for the whole plant, and an hour saved anywhere else is a mirage. Speeding up a step that is not the constraint does not improve the system. It only delivers inventory to the front of the constraint sooner.
Little’s Law. In 1961 John Little proved a relationship that holds for any stable queueing system: the average number of items in the system equals the average arrival rate multiplied by the average time each item spends there. Manufacturing knows it in the form used in Hopp and Spearman’s Factory Physics: cycle time equals work in process divided by throughput.
If throughput is fixed by a bottleneck and you push more work in, the only thing that can change is cycle time. Everything takes longer.
Queues and utilisation. Little’s Law on its own says delivery times lengthen. It does not say throughput falls. Queueing theory covers the rest. In the simplest single-server queue, the average time a job spends in the system is its processing time divided by (1 – utilisation). At 80% utilisation that is five times the processing time, at 90% ten times, and at 95% twenty times. Don Reinertsen built The Principles of Product Development Flow on this, arguing that the largest waste in product development is work sitting idle in queues that nobody measures, not engineers sitting idle.

Mary Poppendieck put the same point to software managers in 2006, in an essay on cause and effect: “if your resources approach full utilization, response time slows to a crawl.” Operations managers and highway engineers knew it, she said, but “in a development environment, managers seem to be unaware that attempting to achieve full utilization slows response time to a crawl and decreases actual utilization. Development organizations are no more immune from the laws of queuing theory than airlines.”
A test department that was running at 85% before AI, and now receives twice the work, is not at 170%. It is saturated, and its queue grows without limit.
Why throughput falls instead of levelling off
In principle a saturated bottleneck still delivers at its old rate. In practice it delivers less, for reasons anyone who has worked in a clogged process will recognise:
- The people at the constraint spend their time managing the queue: triaging, re-prioritising, answering “where is my change?”, and switching between half-finished items.
- Feedback arrives late. A defect found three weeks after the code was written costs far more to fix than one found the same day, and the fix goes back through the same bottleneck.
- Waiting work goes stale. Branches drift apart, requirements move, hardware is revised, and work is redone.
- Batches grow. To cope, people bundle more change into each test cycle or release, and every failure becomes harder to diagnose.
What manufacturing already learned
Toyota. Taiichi Ohno, the architect of the Toyota Production System, treated overproduction as the worst of the seven wastes: making more than the next process needs, or making it sooner. Overproduction becomes inventory, and inventory hides problems. Toyota’s answer was pull. A process makes only what the next process is ready to take, signalled by kanban, and anyone can stop the line when something is wrong. Mary Poppendieck saw this at first hand. Before she wrote about software she implemented one of 3M’s early just-in-time systems in a video tape plant.
An AI-equipped software team feeding a manual test department is overproduction in exactly Ohno’s sense.
Poppendieck made the translation explicit when she first set out lean software development in 2003. The first of her seven wastes of software is “Partially Done Work (the ‘inventory’ of a development process)”. Code that is written but not yet tested, integrated and shipped is stock on the shelf, and a tool that produces it faster produces more stock.
General Motors. In the 1980s GM under Roger Smith spent tens of billions of dollars on factory automation to close the gap with Japanese manufacturers. Sydney Finkelstein’s case study puts the investment strategy at close to $45 billion, and notes that GM’s own internal reports showed the Japanese cost advantage unchanged in 1985 after four years of spending. In November 1986 the Christian Science Monitor reported that two of GM’s newest and most automated plants had higher employment and lower productivity than older plants run by its domestic competitors. Smith’s explanation will sound familiar: “The software has been a problem.”
The same article describes NUMMI, GM’s joint venture with Toyota in Fremont, as a relatively low-tech plant with the best productivity and quality in GM’s domestic operations. The difference was the management system, not the machinery.
Three decades later Tesla repeated the lesson on the same Fremont site. After missing Model 3 production targets in 2018, Elon Musk scrapped a complex conveyor system and said that excessive automation had been his mistake.
The Goal. Goldratt’s novel starts from the same error. Alex Rogo’s plant has installed robots that improved its local efficiency figures. When he checks, the robots have raised inventory and cost without increasing sales. The plant recovers only when the team finds its two bottlenecks, a numerically controlled machine and the heat-treatment furnaces, and runs everything else to suit them.
The pattern is the same each time. A powerful new tool is applied to one step, that step’s numbers improve, and the system’s numbers do not.
What Mary and Tom Poppendieck said about software
I first met these ideas in June 2011, on a day’s training with Mary and Tom Poppendieck, and I have been applying them since. They carried lean thinking into software in Lean Software Development (2003) and Implementing Lean Software Development (2006). Their seven principles, as restated in the second book, are eliminate waste, build quality in, create knowledge, defer commitment, deliver fast, respect people and optimise the whole. The seventh is the one this article is about, and they introduce it bluntly: “Software development is legendary for its tendency to suboptimize.”
They follow it with a vicious circle that could have been written this year. Testing is overloaded, so testing happens long after coding. Developers get no immediate feedback, so they create more defects, which gives testing more work and delays feedback further. That loop is how a clogged bottleneck reduces throughput instead of just capping it.
Mary had already drawn the picture in a 2004 essay on what maturity should mean: “a manager might think that the best way to run a testing department is to make sure that every single person is working all of the time. In order to guarantee maximum productivity of each individual, he makes sure there is always a pile of testing waiting to be done. Down the hall, the operations manager knows better. She knows that if she runs the servers at high utilization, the entire system bogs down, just like rush hour traffic. If only the testing manager would realize that his policy of full utilization of testing resources creates the same kind of traffic jam in software development!” The manager in that essay kept the pile high on purpose. Today the pile arrives on its own.
They also warn against the instinct behind most AI roll-outs, which is to split the value stream into parts and optimise each part’s measure. Their experience was that this almost always makes the whole worse. More code per developer says nothing about whether products reach customers sooner.
Mary’s test of an organisation is the one I still use. In her words, from a 2015 talk proposal: “How long does it take you to deploy a single line of code, learn something useful, and act on the information?” And can you do it reliably and repeatably? If the answer is three months, it will still be three months when an AI writes the line in three seconds.
Tom made the related point in a Business901 interview. He argued against thinking of software development as coding and testing at all, when the real job is working out what is worth doing, getting it into service and getting feedback. “Learning is the key thing, not generating code.”
The evidence from software so far
The published data points the same way, with caveats.
| Source | Data | Finding |
|---|---|---|
| Faros AI, 2026 | Telemetry, 22,000 developers, 4,000+ teams | Epics completed per developer up 66%. Median time in code review up 441.5%, incidents per pull request up 242.7%, pull requests merged with no review up 31.3% |
| DORA, 2025 | Survey, nearly 5,000 respondents | AI adoption now positively related to delivery throughput, still negatively related to stability. Teams with tightly coupled systems and slow processes see little or no benefit |
| Faros AI, 2025 | Telemetry, 10,000+ developers, 1,255 teams | 21% more tasks completed and 98% more pull requests merged. Review time up 91% |
| METR, 2025 | Randomised trial, 16 experienced open-source developers, 246 tasks | Tasks took 19% longer with early-2025 AI tools. The developers believed they had been 20% faster |
| DORA, 2024 | Survey | Each 25% increase in AI adoption associated with an estimated 1.5% fall in delivery throughput and 7.2% fall in stability |
DORA’s 2025 summary is the shortest statement of the problem I have seen: “AI doesn’t fix a team; it amplifies what’s already there.”
Three caveats. First, these are surveys and vendor telemetry, not controlled experiments, and Faros sells measurement tooling. The METR trial is the exception, and it measured early-2025 tools on individual tasks, not delivery. Second, the average picture improved between DORA’s 2024 and 2025 reports. Organisations with good pipelines are turning faster coding into faster delivery, which is the point of this article.
Third, almost all of this data comes from web and enterprise software, where deployment is already automated and code review is the first constraint to clog. I have not found comparable published data for embedded product development. There the constraints are heavier and further downstream. Jama Software recently described the scenario I keep meeting: a team triples its output, and integration testing still happens on two hardware-in-the-loop rigs that were overbooked before AI arrived.
Where the bottlenecks are in embedded product development
These are the candidates I see most often:
- Manual acceptance testing, full or partial: a test team, a bench of hardware and a script.
- Decisions: work waiting for product management or the business to clarify, prioritise or accept.
- Stage gates: evidence assembled by hand for a review board that meets monthly.
- Hardware: prototype boards that are late, scarce or shared.
- DevOps response: build servers, toolchains and pipeline changes behind a ticket queue.
- Code review: senior engineers reading far more code than they used to.
- Compliance work in regulated products: documents and traceability produced after the fact.
None of these gets faster because code arrives faster. Which one is the constraint differs from business to business. You will not find it by asking who is busy, because everyone is. Look for where work piles up and waits.
What to do about it
The remedy is the one lean has always offered: find the bottleneck, fix it, and repeat. Goldratt’s five focusing steps are still the best short version.
- Identify the constraint. Map the value stream from request to shipped product and write down how long work waits at each step. The longest queue is usually obvious once it is drawn.
- Exploit it. Make sure the constraint is never idle and never does work that someone else could do.
- Subordinate everything else to it. Other steps run at the constraint’s pace. For an AI-equipped development team, that means not starting more features than the rest of the business can absorb.
- Elevate it. Add capacity at the constraint, usually by automating it.
- Go back to step 1. Once one constraint is lifted, another takes its place.
Step 3 is the one managers resist, because holding back a team that could be producing code looks like waste. It is not waste if the team’s spare capacity goes into step 4. The time AI has freed in development is the resource for removing the constraint, and AI tools are good at that work too: test automation, simulators and pipeline scripts.
Poppendieck’s advice from 2006 is blunter: “work in small batches, minimize the length of queues of work to be done, and never, ever schedule an organization beyond its capacity to deliver. Do this and utilization will increase. Focus directly on utilization and it is guaranteed to be sub-optimal.” She returned to it in 2022, watching a solar installer sign contracts faster than it could fit panels. A company in that position “learns not to accept work at a faster rate than it can complete work, because doing so does little more than stretch out the time it takes for its people to be successful while lengthening the queue of increasingly impatient customers.” An AI-equipped development team is the eager sales force in that story.
These are the improvements I expect to matter most.
Give teams the authority to decide. A decision that waits a fortnight for a meeting is a two-week queue. Put product decisions in or next to the team, agree the boundaries within which the team decides for itself, and escalate only what is hard to reverse.
Automate acceptance testing. This is where I have seen the biggest gains. I have had great success using behaviour-driven development (BDD) to express acceptance criteria as executable scenarios, then running them against simulation and against real hardware, with test and measurement equipment stimulating and monitoring the I/O. The scenarios run on every change, so the test team’s knowledge is applied on every build instead of once per release. On my own SolidSyslog library, every pull request runs Behave scenarios against a syslog-ng collector acting as the oracle.
Take hardware off the critical path. Most embedded code can be developed and tested off-target. Test-driven development with the hardware behind interfaces, as James Grenning describes in Test-Driven Development for Embedded C, together with simulation or emulation, means real hardware is needed to confirm the work, not to do it.
Automate the release. Build, version, sign and package in the pipeline, and generate the release notes and SBOM there too. A release should be a decision, not a project.
Turn stage gates into evidence. In regulated industries the gate is not optional, but assembling the evidence by hand is. If traceability, test results, coverage and static analysis reports are produced by the pipeline on every build, the gate review can be short and can happen when it is needed. Automated checking, MISRA compliance for example, also takes routine findings away from human reviewers.
Let the team build its own tooling. The people who find a way to lift a constraint are usually the people working at it, and the work is small if they are allowed to do it. The SolidSyslog pipeline above is an example. When I started the FreeRTOS port, the BDD scenarios already ran on Linux and Windows in GitHub Actions. I had never used QEMU. In under a day, with AI doing the research and most of the scripting, I had chosen QEMU, picked the closest existing board emulation, added a cross-compilation lane, built a Docker container running the firmware under QEMU, and had the first scenario passing on every pull request. The full suite for everything FreeRTOS supported took a little under a week. In a corporate R&D department the same change needs a tool approval, a server sign-off and a slot in the DevOps team’s queue, and it takes weeks if it happens at all. The improvement waits in a queue, just like the code. DORA’s 2025 report found a direct relationship between the quality of an organisation’s internal platform and the value it gets from AI, and this is the mechanism: a platform the team can change itself turns AI’s spare capacity into capacity at the bottleneck.
Keep batches small. Small changes are quicker to review, test and diagnose, and they keep feedback close to the work.
Do these one at a time, starting with the actual constraint. Automating the release is wasted effort if every release then waits six weeks for manual testing.
Closing
AI coding tools do make embedded software development much faster. I use them in my own work. They do not make product delivery faster by themselves, for the same reason GM’s robots did not make GM competitive. Delivery speed belongs to the whole system, and the system is as fast as its slowest step.
The businesses getting the benefit are the ones that had already done the lean work, or are doing it now. For everyone else the instruction has not changed since Ohno: find where the work is waiting, fix that, and look again.
Or, as Mary Poppendieck put it twenty years ago: “small measures cause small results; global measures promote globally optimized results.” Lines of code per developer is a small measure. Time from request to shipped product is the global one.
References
- Mary and Tom Poppendieck, Lean Software Development: An Agile Toolkit, Addison-Wesley, 2003.
- Mary and Tom Poppendieck, Implementing Lean Software Development: From Concept to Cash, Addison-Wesley, 2006. Chapter 2 excerpt on InfoQ.
- Mary and Tom Poppendieck, Leaders in Lean Software Knowledge, Business901 podcast transcript.
- Mary Poppendieck, Lean Software Development, Lean Essays, 25 April 2003.
- Mary Poppendieck, Toward a New Definition of Maturity, Lean Essays, 1 February 2004.
- Mary Poppendieck, Cause and Effect, Lean Essays, 4 December 2006.
- Mary Poppendieck, The New New Software Development Game, DevOpsDays Minneapolis 2015, talk proposal.
- Mary Poppendieck, When Demand Exceeds Capacity, Lean Essays, 11 June 2022.
- Eliyahu M. Goldratt and Jeff Cox, The Goal: A Process of Ongoing Improvement, North River Press, 1984.
- John D. C. Little, “A Proof for the Queuing Formula: L = λW”, Operations Research 9(3), 1961.
- Wallace Hopp and Mark Spearman, Factory Physics, 3rd edition, 2008.
- Donald G. Reinertsen, The Principles of Product Development Flow, Celeritas, 2009.
- Taiichi Ohno, Toyota Production System: Beyond Large-Scale Production, Productivity Press, 1988.
- Sydney Finkelstein, GM and the Great Automation Solution, Tuck School of Business case study.
- Paul A. Eisenstein, GM’s downshifts big plans for high-tech wonders in its plants, Christian Science Monitor, 17 November 1986.
- Kirsten Korosec, Tesla CEO Elon Musk Admits ‘Humans Are Underrated’, Fortune, 13 April 2018.
- DORA, Highlights from the 10th DORA report, Google Cloud, October 2024.
- DORA, Announcing the 2025 DORA Report: State of AI-assisted Software Development, Google Cloud, September 2025.
- Faros AI, The AI Productivity Paradox Report 2025.
- Faros AI, Ten takeaways from the AI Engineering Report 2026: The Acceleration Whiplash, April 2026.
- METR, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, July 2025.
- Jama Software, From Faster Engineering to Product Velocity: Why AI Moves the Bottleneck, November 2026.
- James W. Grenning, Test-Driven Development for Embedded C, Pragmatic Bookshelf, 2011.