Lean and agile software delivery solve different problems. Lean cuts waste and shortens the flow of work from idea to production, mainly through small batches and limits on work in progress. Agile organises that work into short iterations with frequent feedback from the people who know the business. Most strong product teams use both, inside one team that owns an outcome.
What is the difference between lean and agile software delivery?#
Lean asks "how does work flow, and what slows it down?" Agile asks "are we building the right thing, and how fast do we find out?"
Both push back on big up-front plans, but they act on different parts of delivery:
| Lean | Agile | |
|---|---|---|
| Core question | Where is the waste between idea and production? | Are we learning fast enough from users and experts? |
| Roots | Toyota Production System, manufacturing | 2001 Manifesto for Agile Software Development |
| Unit of focus | The flow of work through the whole system | The team's iteration and feedback loop |
| Typical practices | Small batches, WIP limits, value-stream mapping | Short iterations, reviews with stakeholders, backlog refinement |
| Signals to watch | Lead time, batch size, work waiting in queues | Working software per iteration, quality of feedback |
| Common failure | Delivering the wrong thing very efficiently | Ceremonies that run on time while work piles up half-done |
In practice: lean shapes the system the work moves through. Agile shapes the rhythm of conversations about what that work should be.
Where did lean and agile come from, and why are they so often confused?#
They come from different places, a car factory and a software meeting. They get confused because the people who brought lean into software described it as an agile toolkit.
Lean comes from Toyota. In the Toyota Production System, eliminating waste (muda) is a core principle of Just-In-Time, the system's main pillar. Toyota sorts muda into seven types, including transportation, inventory and motion. Mary and Tom Poppendieck adapted these ideas for software in their 2003 book Lean Software Development: An Agile Toolkit. Its principles include eliminating waste, building quality in, deferring commitment, delivering fast and optimising the whole.
Agile goes back to February 2001, when 17 people met at the Snowbird ski resort in Utah and wrote the Manifesto for Agile Software Development. Its four values put individuals and interactions, working software, customer collaboration and responding to change ahead of their more formal alternatives.
There are three reasons the terms blur:
- The best-known lean software book has "agile" in its subtitle.
- Both reject long, plan-driven projects, so either word gets used for "not waterfall".
- The research mixes them. DORA, Google's long-running software delivery research programme, says working in small batches is part of lean product management, and agile teams adopt the same practice.
What does lean look like in a product team: waste, flow and small batches?#
A lean product team keeps work moving in small pieces and treats anything that waits as waste.
Here is how Toyota-style waste tends to show up in a software team. These mappings are our reading, not a formal standard:
- Inventory → branches, tickets and features that are started but not shipped.
- Overproduction → features built before anyone confirmed users need them.
- Transportation → hand-offs between separate frontend, backend, QA and ops teams.
- Waiting → changes queued for a weekly review, a test environment or a release window.
- Defects → bugs found late, after the person who wrote the code has moved on.
The main lean practices:
- Work in small batches. DORA finds that small batches shorten feedback time, make problems easier to triage and stop teams falling into the sunk-cost fallacy.
- Limit work in process. DORA lists WIP limits as a capability: rank the work and finish a small number of high-priority items before starting new ones.
- Map the value stream. Follow one change from idea to production and record where it waits. The waiting is usually far longer than the working.
- Build quality in. Run automated tests and checks on every change, not in a testing phase at the end.
What does agile look like in a product team: iterations, feedback and embedded experts?#
An agile product team works in short iterations, shows working software at the end of each one, and changes course based on what the business experts say.
The Manifesto's principles call for delivering working software frequently, from a couple of weeks to a couple of months, with a preference for the shorter end. Many teams now ship far more often than that. What matters is that the iteration is a feedback loop, not a deadline.
Signs agile is working:
- Experts are in the room. The people who know the domain take part in planning and reviews, not just in sign-off.
- Working software is the measure. Demos show real behaviour in a real environment, not slides or status reports.
- The backlog changes. If priorities never move after a review, the team isn't using the feedback.
- The team owns an outcome, not just a list of tickets.
That is how our Product Engineering Pods are set up. A complete team (lead, engineers, QA, DevOps and product) embeds with the client's subject-matter experts, joins the same stand-ups and channels, and owns a slice of the roadmap from first commit to production.
Do product teams have to choose, or do lean and agile work together?#
You don't have to choose. Lean keeps the flow fast and the batches small. Agile makes sure each batch goes to experts who can tell you whether it was worth building.
Each one covers the other's typical failure. Agile without lean gives you two-week sprints that end with ten features 80% done. Lean without agile gives you a fast pipeline delivering the wrong features. Combined, each small change goes straight to feedback and the feedback decides the next small change:
To run both in one team:
- Set the iteration around feedback: regular reviews with the domain experts.
- Set the flow around batch size: every change small enough to review in one sitting and release on its own.
- Track one lean signal (lead time from commit to production) and one agile signal (how often expert feedback changes the backlog).
- Give the team the whole path to production, so no hand-off brings back the waste lean removes.
How does AI-written code change lean and agile delivery, and why do quality gates matter more?#
AI makes code fast to produce, so the slowest step moves to verification. Small batches and enforced quality gates become the main controls on delivery risk.
The research is consistent on this. DORA's 2024 report found AI adoption raised individual productivity but hurt software delivery stability and throughput. It concluded that basics such as small batch sizes and solid testing still matter. Write-ups of the report give estimates: for every 25% rise in AI adoption, roughly a 1.5% drop in delivery throughput and a 7.2% drop in delivery stability. The 2025 DORA report describes AI as an amplifier. Without strong automated testing, mature version control and fast feedback loops, more changes lead to more instability. DORA also notes that small batches amplify AI's positive effect on product performance.
In lean terms, AI is a new source of overproduction. An assistant can produce a 2,000-line pull request in minutes, and that becomes inventory nobody has verified. In agile terms, fast code doesn't help if experts are reviewing features they can't trust.
What to change:
- Cap the size of AI-generated changes. The small-batch rule applies whether a person or a model wrote the diff.
- Make the gates mandatory. Our standard is three gates on every release: tests show it works, security checks show it's safe, and a senior engineer's review confirms it's right. Nothing ships without all three, whoever or whatever wrote the change.
- Keep release evidence. Store test results, scan output and review approval with each release, so you can always answer "how do we know this works?"
Our guide on how to verify AI-generated code before production covers each gate in detail.
How can you pilot a lean-agile pod on one outcome before scaling it?#
Pick one outcome. Agree success criteria up front. Have one pod deliver it with experts involved and gates enforced. Then decide from working software whether to scale, adjust or stop.
- Choose one outcome that matters. It should be a real slice of the roadmap with an expert who will give feedback, not a sandbox project.
- Write the success criteria before work starts. Include a lean measure (lead time, change size), an agile measure (expert acceptance of what's delivered) and a quality measure (every change passed tests, security checks and review).
- Staff a complete pod. Lead, engineers, QA, DevOps and product in one team, so the pilot can't stall on hand-offs.
- Run it in production conditions. Same pipeline, same gates and same review cadence you would use at scale.
- Hold a decision review. Compare results against the criteria, then scale, adjust the scope or stop.
This is how our engagements start: a paid pilot with one pod and one outcome, criteria agreed up front, judged on working software. There are no long-term contracts, so you add pods only when results justify it. For more detail on scoping, see what a paid software vendor pilot needs.
Conclusion#
Lean and agile aren't competing ways to do the same thing. Lean removes waste and keeps work flowing in small batches. Agile keeps that work tied to feedback from the people who know the business. With AI writing more of the code, the combination needs a third part: mandatory tests, security checks and review on every change. The lowest-risk way to see all three working together is one pod on one outcome.
Want to try a lean-agile pod on a real outcome? Talk to an engineering lead →
Frequently asked questions
Is Scrum lean or agile?
Scrum is an agile framework. It organises work into fixed-length sprints with planning, review and retrospective events. It doesn't require lean practices like WIP limits or small batches, but it works much better with them. Many teams run Scrum's feedback cadence on top of a lean flow of small, independently releasable changes.
Is Kanban lean or agile?
Kanban comes from lean. It makes work visible and limits work in progress so items flow instead of piling up. Many agile teams use it in place of, or alongside, sprints. It's a common way to add lean flow to an agile team.
Which metrics show whether a lean-agile team is working?
Use flow metrics for the lean side: lead time from commit to production, change size and work waiting in queues. For the agile side, track how often working software reaches domain experts and whether their feedback changes priorities. Add quality signals too, such as change failure rate and whether every release has test, security and review evidence.
Does AI make agile iterations unnecessary?
No. AI speeds up writing code, but it doesn't tell you whether you built the right thing. That still takes feedback from users and domain experts. DORA's research suggests AI raises delivery risk unless teams keep small batches, automated testing and fast feedback loops. Those are exactly the habits lean and agile teach.
How long should a pilot run before deciding to scale?
Long enough to deliver the agreed outcome and produce working software you can judge against criteria set up front. The criteria matter more than the calendar. Agree what "success" means for flow, expert acceptance and quality before work starts, then make the scale, adjust or stop call against them.
- lean
- agile
- software delivery
- product teams
- DORA
- AI-generated code
Newsletter
Get new articles by email
A short monthly round-up of what we've written on engineering pods, quality and AI. No spam.
