1/ An unfortunate management student put a quarter in me in my DMs so I might as well put it in public:

Why Lean Software Dev is Wrong.

I think a big misunderstanding has been to think of software development as manufacturing. That also goes to my gripe with how Lean was translated to software development, which I think made this same mistake. I would need a whole thing on that as well (I'm assuming you read my thing on Team Topologies, which was basically to say that it was wrong in way too many words). So before buying into Lean Software dev and Kanban, I would actually go back and read for example Toyota Way, which I found super interesting when I read it (it's been a few years).

Mapping Lean to other disciplines starts with trying to figure out "what is the factory?" and "who are the workers in the factory?" And this is where it's very easy to miss and Lean software dev missed completely imo.

2/ If you look at modern software development it is, to me, obvious what the factory is an example of: It's a CI/CD pipeline, it's basically DevOps tooling and monitoring. A similar architecture exists for other computer programs that do this type of process: take various pieces of stuff and compose them together. You'll see that architecture in audio and video processing/mixing software, a well known OSS example is ffmpeg. But you also see it in operating systems for example in composers like Wayland or X11.

Basically: there are no actual people in the factory in software development. Lean Software dev is a massive misunderstanding and so is by extension Kanban etc

I should really write a blogpost or something on this.

But if you read Toyota Way you will see something that looks a lot like software dev, but it's not very prominent: it's the people designing the factories and the people designing the cars.

3/ I really do recommend going back to the primary sources from Toyota. Because software dev has a weird attribute, making 1 app locally on your machine that you deploy locally to your phone as a hobby, can take days/months/years. But once it is "done" you can put it in an app store or online, and all subsequent copies are "free to produce". This is not common in manufacturing. Making item 2 and 3 has cost, in materials and labour. But in software all of, or the overwhelming amount of, cost is in making the first one.

So the perspective is wrong. Developers don't produce code. Developers are trying to design a solution, and that is not done in isolation and more isn't necessarily more.

Like imagine you like a minimalistic style, putting more and more stuff into your house doesn't make it better, it makes it worse.

The goal isn't to write code faster, it's to make something that is valuable to someone.

4/ So this is more like making a bespoke suit for someone. You need to try to get them to tell you what they want, you can try to show them different things they might not be familiar with, and most of the time they probably don't know what they want. So the process of making good software is about trying to find out what people want, even when they don't know themselves. That is a lot of trying stuff, a lot of interaction, a lot of back and forth. And that's not bad, that is actually optimal. The point is not to make a suit, the point is to make a suit that they will love.

The manufacturing perspective just doesn't fit: we have no material cost (copies are free), we have no labour cost for manufacturing (copies are free), we don't need a factory (copies can be made on a laptop). This is a very different thing than manufacturing, even designing for manufacturing, because you can design a bridge, but building the bridge still costs money. And so does the next bridge from that same design. That's not software.

Another weird thing about software is that we can fundamentally change it after it's "done". Even after the customer has it. We can continue to change it, for decades and decades.

5/ I sometimes compare it to trying to make a garden, it's never done, but it's still here, some years it's better than others and some years it actually might get worse.

My point is that your mental model for "what making software is" is extremely important when trying to figure out how to "manage" it.

6/ This whole thread is also relevant to the question: will AI take my programming job?

7/ Since people are already misunderstanding me: «the factory» is a kind of software architecture you see in a bunch of different software, for example audio mixers, video editing, GUI composition etc etc.

It’s literally a kind of software architecture. Not super common, but not uncommon either. For example in video players or games you will see this architecture often. A very concrete manifestation is triple bufring in rendering.

8/ We misunderstood/misapplied it, and it’s been going on for over a decade. Tbh (which would be a whole blogpost) this architecture (the factory) occurs all over software programs. I could list dozens examples off hand (I have listed a bunch already). It’s largely not interesting to software development as a field. It’s very well understood.

We’ve written software with this kind of architecture for probably at least half a century.

9/ People are clearly not getting my point… I’m clearly struggling to convey it properly. Clearly.

Yes! It’s recognizable! It’s a very common architecture!

It’s everywhere!

But it’s In Our Programs!

We use it all the time!

Unix pipes is an example (though we usually don’t write that complicated Unix pipelines).

Java steams, functional programming… it’s absolutely everywhere.

In our programs.

10/ Toyota Production System (/Lean) is extremely understandable to programmers BECAUSE IT IS A PROGRAM.

It’s a program being executed by a combination of humans and machines in an actual physical factory. But as a program it’s very basic. It’s not very complex or interesting in the field of software engineering. Which is understandable because it’s not being run on a computer.

11/ Of all the worst things that happened in software dev because of this absolute nonsense, the biggest is the idea of Waste.

Y’all know how to profile software, these people have nothing to teach you.

12/ A much better explanation in the shape of a blogpost.
https://patricia.no/2025/05/30/why_lean_software_dev_is_wrong.html
Why GUIs are built at least 2.5 times | Patricia Aas

Or Why I Think Lean Software Development is Wrong

Patricia Aas

@Patricia
I've read your blogpost: you're absolutely right. It matches exactly my observations.

I never wanted to build UIs. Nobody else liked it either and their output was unsellable. So I ended up doing UI on top of my *real* job in almost my entire career.

There is *one* thing that I've learned quite early: figure out the customer's *real* painpoints (you won't find them in any written material). You need to speak with them over and over again, and you need to discern *your own* pets from *user needs* and be willing to let go.

TL;DR: it's the art of never-ending careful listening to your users that makes you successful. The rest is craftmanship, automation, knowledge.

@DanielaKEngert @Patricia My professor at uni was saying "An analyst who gives the client what the client wanted should be fired." Should give what the client *needed*.

@chebra @Patricia
Very true - this distinction is important!

I can barely remember how many time a PM from the customer side, or our PM, came up to me with This Simple Solution ™ to be implemented by me ("The hard work is already done by them, the simple part is left for me").

The hard part was then to convince all stakeholders to figure out the customer's *real* problem that they *actually* needed to be addressed. Oftentimes, that problem *was* already addressed by just using existing functionality that I've architected into the machine, often long before, as the need became apparent by talking to e.g. the machine operators, or the IT people that had to fit the machine into their factory management system. In many cases, there was a big surprise for them to learn that Their Simple Solution ™ was not addressing their needs at all, but rather a rough approximation with many gaping loopholes that many of the stakeholders usually can't foresee.

@Patricia still not finishing reading the blog post, but i must say, you got me really into (re)thinking many thinks. With some "So that was my bad gut feeling when making the decision" that now makes sense. Therefore one of the better blog post I ever read in my live. I also did some mistakes, based on your ideas, that made me worry about a project at work. I knew i did something wrong, but not where/what exactly could be done better (even through now it feels obvious with the new perspective)
@sickeroni 💜 all my advice always comes from me doing it wrong first. Often more than once.
@Patricia doing mistakes is normal.
Learning from mistakes is a skill I wish, more people would have.
@Patricia So, putting on my dickhead hat, what I'm hearing is that after a feature is delivered, on spec, we should make sure to get *really* honest feedback so we can upsell a second iteration of the feature. I think that's a message PMs can understand.
@drgroftehauge lol, my takeaway is rather that even people who design things professionally don’t know what they want. So the rest of us have zero chance. Fixed design up front is an illusion. Design, dev and users need to iterate together.
@Patricia @drgroftehauge and management need to stay tf out of it because they will make you turn everything into homermobile if you let them

Thanks for writing this, @Patricia. Funny enough I have been pondering and experimenting this for years now too and I’m hoping to put my thoughts down on this in the next months and once I have, I’d love to hear your take. 🙂

For now, I can share my core thoughts:

1. Software is the only engineering discipline that has not been industrialised
2. If I think of building a platform product (like Spotify), I think of Disney World
3. I believe we lack clarity in the orchestration level that bridges…

… the vision (what the customer wants) and the execution (what we design and build); which what you describe partially as experimentation.
4. So for certain types of software like enterprise platforms I believe that we can describe what it should do through a billing materials and patterns.
5. Other software like a browser engine, Photoshop, etc may need something else.

As said, I need to put my thoughts down much more comprehensively though. 🙂

@Patricia

@njyo I’d love to read the long form, I do think you’re wrong about 4 though 😅
@Patricia will share once I have something cohesive and am looking forward to your critique 🙂
Thanks!
@Patricia love this article. You've managed to write down something I've been trying to put together for literally years - "software is different". Thanks
@Patricia I am giving the biggest side eye as someone who has had to teach a lot of people how to profile from first pointing out that they even need to.

@Patricia

(Agree with you 100% that manufacturing analogies for software development have always been misleading, and a problem.)

But anyways, …

@Patricia

I was thinking that the focus on reducing and eliminating waste is one of the better and more general and useful concepts that come over from Lean (manufacturing and/or design). Sure, we're not wasting material supplies in software development, because RAM and disk storage are practically perfectly recyclable.

But we waste TIME.

And, in design, *time* is (most often) our most precious resource.

Human time, and even CPU time, disk space, network bandwidth and other such resources.

@JeffGrigg But we even have an expression for that in programming "Premature optimisation", the problem we have the most is that we make the wrong thing. Typing faster doesn't produce value. What produces value is typing the Right Things. That is what is hard in software dev.

@Patricia @JeffGrigg this is the difference between an efficient system and an effective system

once an efficient system is running, it can be hard to make it effective because the resources to transform it are already captured by all kinds of 'important' components

@Patricia @JeffGrigg "you don’t rent my fingers but my brain", indeed.
@Patricia
Wait? Waste? In software dev? How? We don't make anything physical? 😂

@worldwidewerner @Patricia I’ve been broadly nodding along with this thread, but there does seem to be a misunderstanding here.

In TPS, waste was “muda” which I think is possibly better translated as “excess”, which in turn meant “anything that increases the overheads or lowers the output of the factory”.

Lean (confusingly) means something considerably different by “waste”. It means “anything that does not add value for the customer.”

I hate that phrasing, but I get what they mean to say. It’s about any effort spent that does not result in software that does its job better (which can include changing that job when you _understand_ it better). It’s about waste in the process, not the product.

One of the problems with Lean is it misses or de-emphasises important dimensions of that aim. This list (https://en.wikipedia.org/wiki/Lean_software_development#Eliminate_waste) is pretty much entirely about things you would intuitively think about as “a waste of my time”. That’s what happens when you take an idea that’s primarily about elegance and you forcibly mash it into minds that have been taught to think in terms of time and motion.

I don’t recommend people follow any methodology religiously. I do find Lean a useful lens to look at software through. Even considering the things it misses, I have encountered each of those “wastes” far, far too many times. And they’re worth harping on about because people are — weirdly — resistant to fixing them, perhaps because they can’t see the cumulative impact.

(The one exception would possibly be “partially done work”, because sometimes that’s a good thing. That sometimes means you worked out you were doing the wrong thing and stopped. Better late than never!)

(Aaand this should’ve been a blogpost, sorry)

Lean software development - Wikipedia

@worldwidewerner @Patricia Reconsidering: maybe the time-and-motion focus is due to it being modelled too closely on TPS - like you’ve been saying, software development is not a factory. TPS pays lip service to “value for the customer”, but really (POSIWID) it’s saying “you can do anything to optimise as long as it doesn’t upset the customer”.

A lot of the value is outside of that process, in activities like design, documentation and after-sales. Perhaps because Lean followed TPS too closely, that’s why it seems so weak on those activities too?

@decoderwheel @worldwidewerner yes, I think the understanding of the metaphor (what is the factory etc) had fundamental implications for how it was applied and interpreted. And I definitely think there are parts of TPS tech could learn from. But unfortunately not the ones we focused on. Focusing on waste is the wrong lens. We are doing discovery of value, not production. We should «waste» because we are constantly learning and iterating, changing and refactoring. TDD (for those who like that) is writing the same code in a million tiny iterations. The problem with a waste lens is that it is (in our profession) extremely subjective, you say waste, I say learning or avoiding a mistake or improving. It makes sense when you think of the factory as the program: we have words for those things: profiling, benchmarking, optimization (directly on computer resources) or linting, testing, monitoring, version control, regression (which are about quality but results in reducing waste in the form of customer satisfaction, support, debugging etc).

It’s a misunderstanding/misapplication. What we build is «the factory» we are not in a factory.

@Patricia Software inventory (long lived feature branches often never merged) is the most obvious example of this and it truly is an issue for speed of feedback.

The lean strand in software engineering is only interesting if you’re coming out of an enterprise environment in which case some of the stuff may be insightful (but really anything would be at that point).

There is a there there in queuing theory (Product Development Flow) and iteration loops (Certain to Win).

@Patricia Maybe it's a misunderstanding of the term "lean" on my part, but I've always understood "lean software development" to mean a reduction in formalism.

E.g. doing requirements engineering, architecture and planning without producing formal documents.

This works fine for a small project where the team can have a common understanding of the requirement and solution space.

@exception
I think the lack of a common definition of what the words mean influences the discourse a lot. Someone who read the books, or has worked with someone who has some special title associated with it, will have a different understanding than someone (like me) who mostly understands the term through hearsay and intuition.
@Patricia

@syklemil @exception as I said here (quoted), but also it is everywhere even if you don’t know that’s where it comes from. Kanban, all the talk about Waste, measuring the time a task is «in progress», so many things that people think are «agile» come from this misunderstanding.

https://social.vivaldi.net/@Patricia/114580703866929875

Patricia Aas (@[email protected])

@[email protected] Yeah, understandable but that is not what uppercase Lean is about. It comes from manufacturing who got it from supermarkets. It’s also known under the more colloquial term: Just In Time Production. It was mapped as a metaphor to software development, and that is what I am criticizing in this thread.

Vivaldi Social
@Patricia
yeah, I'd also say the SRE thing about reducing toil maps to kaizen.
@exception
@Patricia I've always thought of the "factory" in software as the I/O pipeline. In other words, you get "raw" input and produce a product from that input, whether that's a UI displaying the output of keys pressed on a keyboard or some crazy data lake data warehouse thing or some AV processor. In that sense, I have always thought that the factory metaphor holds really well.

@davidvedvick people are clearly not getting my point… I’m clearly struggling to convey.

Yes! It’s recognizable! It’s a very common architecture!

It’s everywhere!

But it’s In Our Programs!

We use it all the time!

Unix pipes is an example (though we usually don’t write that complicated Unix pipelines).

Java steams, functional programming… it’s absolutely everywhere.

In our programs.

@Patricia have you ever thought about writing a book
@mrsbeanbag Yes, but I’d need help, my brain can’t get hooked on it like with programming and I need someone to drag me along.
@Patricia @mrsbeanbag
Dont know if you are really thinking about a book, but in the QA/Testjng space there are quite some authors; who might or might be open to work with others on a book….. just throwing this out; could connect you, if wanted.
@Patricia @mrsbeanbag You could send a proposal to https://pragprog.com/ they are setup to help their authors drag their brain along.
Pragmatic Bookshelf: By Developers, For Developers

We improve the lives of professional developers. We create timely, practical books on classic and cutting-edge topics to help you learn and practice your craft, and accelerate your career. Come learn with us.

@Patricia If it makes you feel better about lean development, good books on the subject do acknowledge those differences and try to elucidate them, I like the book "Flow" for example
@Jakeout I might still be licking my wounds after Team Topologies, but just the word «flow» pushes my buttons, and tbh both the word Lean and flow wrt software dev builds on exactly the fundamental misunderstanding I’m trying to describe. They are wrong. That’s not what we do. That’s what our programs do.

@Patricia Heard, it sounds like you've had negative experiences with both kanban and flow (I haven't experienced the team topologies book, personally) ...

Some of the things you called out as opposing it (costs of sharing software being low, need to make something good with customers being critical), I have understood as key parts of what kanban is supporting, but I don't want to lean too far here into Mastodon Contrarian, and I'm definitely sorry you've had those experiences!

@Jakeout The problem is that Kanban and flow come from this misapplication. It’s basically homeopathy. And funnily enough, the reason they hold on to humans in the factory in Toyota Production Systems is that they are very advanced and easily changed. You can make people do whatever. But this is not connected to anything except a massive misunderstanding when trying too hard to apply a metaphor.

@Patricia I know I'm still describing a gulf between our experiences, but in your bespoke coat analogy, the training I give teammates on kanban & flow, we teach folks (including a similar hands on activity) to be the bespoke coat people.

I'm still worried that you're describing a version of kanban or flow that is different than what I understand or have learned.

@Jakeout maybe check out my thread here, and the article I reference there, and the we can try again?

https://social.vivaldi.net/@Patricia/114581244310212128

Patricia Aas (@[email protected])

1/ Rebecca Wirfs-Brock (@[email protected]) shared (on LinkedIn link in next post) this insightful article on models in general, but organizational models in tech in particular. And I think it explains a lot better than me something that is very crucial to understand my perspective and I think I can possibly use it's language to explain what I mean. Before I do that I will just copy paste my replies to her there, because threading on LinkedIn is a mess and this deserves a top level thread all to itself. https://wirfs-brock.com/rebecca/blog/2022/09/20/critically-engaging-with-models/

Vivaldi Social
@Patricia thanks! Will do a read through and put more thoughts into it later 🙂
@Jakeout @Patricia I suggest you go to the source of the idea of flow to get the feel for what it means, that is to Eli Goldratt's books introducing Theory of Constraints: "The Goal", "Crirical Chain" and recent "Goldratt's Rules of Flow" (by his daughter Efrat). Here's a summary: https://hennyportman.wordpress.com/2024/07/13/summary-and-review-goldratts-rules-of-flow/
Summary and review Goldratt’s Rules of flow

Dr. Eli Goldratt once stated that he would eventually replace Critical Chain Project Management. Although he passed away in 2011, his daughter, Efrat Goldratt-Ashlag, authored “Goldratt’s Rules of …

Henny Portman's Blog
@Jakeout @Patricia Goldratt's paper "Standing on the Shoulders of Giants" is also a nice summary of ToC, CCPM and flow management in project environments: https://www.tocico.org/page/StandingontheShouldersofGiants