Shop-floor quality and software craft — stop the line, do not pass defects

Toyota TQM for software: quality when AI can write the code

This reflection comes from the huge impact I see AI having on the software-development labour market — the same pressure I wrote about after reading Garrison Lovely. I will not re-explain that political economy here; the companion piece is Reading Obsolete: ethics and craft in an AI labour race. This article starts where that one leaves the reader: if the ground is moving, what craft posture still makes a sustainable profession?

I did not learn Total Quality Management in an IT shop. I learned it earlier — first in construction services in 2000, then in services inside cooperatives, then in industry (automotive-adjacent work), long before Cursor sat in my editor. Software came later. The vocabulary I still carry is older than this labour moment: kaizen (continuous improvement), jidoka (autonomation), genchi genbutsu (go and see at the actual place) — more about this later in this article — and waste you can walk to on a shop floor.

In Tione, on 4 November 2009, I heard Alberto Galgano speak at a seminar on building quality in modern enterprises and in public administration. Around that time I read his Qualità totale. Il metodo scientifico nella gestione aziendale (Total Quality. The scientific method in business management). What stuck was not a Japan brand. What stuck was a system: quality is not a department at the end of the line; it is how every step refuses to pass a defect downstream.

I have always tried to drag that posture into programming. Reality is harder. Large parts of IT — not just small firms under delivery pressure: I saw the worst examples in big players of the Italian and French markets — are organised around getting the job done, with little interest in how it is done. Ethics and empathy in the craft are not the default culture. That is not my private complaint: I am describing the market. I was not employed under quality promises or quality tasks — I have no personal score to settle here. On empathy in the craft, see also Words are important, respect is practice (including the Chris Hartjes / Grumpy Programmer thread cited there). The companies and freelancers who write good code as a quality practice are few. Too often, when they do, ego builds a wall between them and everyone else. Simple facts. No theatre of judgment — any working developer can see the split.

Why the question is urgent now

Now almost every developer I know can see how well AI writes code. That is not unexpected for me. It is still surprising in the room. The model is not doing something you could never have done. It is doing, at speed, what SOLID, tests, clear boundaries, and refusal of junk already asked of us — principles many programmers refused because quality is a choice of responsibility and consistency, not the latest trendy tool.

Indirectly, the AI assistant even practises a kind of empathy toward the next reader of the code — and the assistant often does that for its own interest, not as a gift to programmers. Context windows are limited; what the model can “remember” is finite. So it writes comments and docs because that makes it easier to pick the job up again later. Word of caution: I also insist on documentation in the IDE — see How I write code with Cursor — so I may be giving the assistant that direction myself (expected, if you are a software developer). The end result still matters: the docs land in the repository (for non-technical readers: the container of the written code — simply the list of files and their content). Good documentation then serves humans, AI, the IDE, and automated tests that need written criteria to verify “things” without guesswork.

So the sentences I keep hearing among seniors are the like of:

“Wow — AI writes much better than I do. I’ve never seen code written so cleanly. There is no going back.”

The next sentence — for many (I would say those who look at the market and try to see what the next year could look like) — is still:

“What do we do now?”

If your ego is large, you answer that your experience is still indispensable — and today, much of it still is — and you do not change posture. You become an orchestrator. The ego feeds on being the conductor of the orchestra. I have heard the sales version out loud: we are not selling you the ten minutes the AI spends writing code; you pay hundreds of dollars because of the years I suffered to instruct the model for those ten minutes.

I do not think that story lands cleanly with clients. The experience is the same experience we sold yesterday. Clients already paid — and still pay — something like twenty to fifty dollars an hour on average in the markets I know. If a reduction of billed hours is excluded by the business model, how does the “conductor” premium go down well? Do agencies jump from roughly forty dollars toward two hundred and fifty? I do not see that as a stable future. (Again: the labour frame is in Reading Obsolete — not repeated here.)

Another future I do not treat as likely — at least for ordinary day-rate work — is the one many voices still sell: that AI is only a bubble, robbing jobs to enrich big tech, and that it will sooner or later explode and leave the old labour market intact. That reading could be partly true about capital; I do not want to argue that political-economy claim here. I want to stay on real job possibility. Among those voices is NixCraft (see his Mastodon posts if you want to know more about that), which has been an authority in its own right in the Linux world for roughly twenty years. They recently treated the midterm elections in the United States as an early step toward “limiting AI.” I do not agree — not in any sense that would even slightly reverse the labour-market pressure I see day to day. I may be wrong; I am only describing what I see. The political aim, as I read it, is mainly to avoid or limit AGI or superintelligence (again, see Reading Obsolete) — not to stop AI assistants in the IDE. We can still join a fight for a better world around AI. Many of us must still earn the day for our families. That confusion has to be cleared before we can talk about craft posture with a clear head.

A possible future is TQM

The possible future I can still believe in is closer to Total Quality Management than to a fivefold rate card.

You set up a system that welcomes juniors again — the same pressure and opening I wrote about in Niche projects as future prospect and, as a concrete stack field note, in Umbraculum as a niche stack example (illustrative, not an endorsement). Seniors stop pretending their value is how fast they produce code (AI already won that race) — or being the one who saves your day with their bug-catching capabilities (that is true, by the way — but AI is going to win that race as well, if it is even still open at all). Their value becomes tested code that reaches production with less cost and fewer — or no — bugs. The senior role becomes, in practice, a quality manager role: apparatus, gates, stop-the-line culture, teaching, and refusal to pass defects downstream.

That is absolutely possible. After more than a year of AI assistants that claim 5×, 10×, even 20× productivity for any developer, I still hear almost nobody talk about it. That silence is bad. We may be missing an opportunity.

TQM and quality culture feel extraneous to much of Italian working culture where I work now — and often to European software culture more broadly. That is not a romantic claim about Toyota or Japan. I have read Tiziano Terzani’s In Asia; his Japan reporting includes the Fanuc visit in “Il robot e l’imperatore” (The Robot and the Emperor), with the chill of a society that fabricates robots and also carries the depression and suicide rates he refused to treat as a postcard. I am not selling a national myth. I am pointing at a soft push for the IT labour market: a direction that can still let juniors enter, and can still give seniors a profession that is not only “you are the indispensable orchestrator” — a profession now at stake for many.

Core principles (Toyota TQM, as I carry them)

These are the names I keep on the desk. They are industrial vocabulary. Software can translate them without cosplay.

  • Kaizen (continuous improvement): daily, small-step improvements driven by everyone who touches the work — not a yearly “innovation theatre.” In code: shrink waste (muda) — rework from unclear requirements, waiting on broken builds, features nobody uses, repeated code with no single implementation to operate, guessing what “done” means — and fight that last one by writing unit tests that clarify the goal in code — then chase zero defects as a direction, not a slogan.
  • Jidoka (autonomation): build quality into the process — automation plus human judgment. Anyone can stop the line when a defect appears (Andon). In software: any developer or gate (here meaning automated tests and other automatic checks) can halt a merge, a deploy, a release when the signal is red.
  • Jikotei kanketsu: do not pass defects downstream. The next process is your customer. In software: do not hand broken work downstream — not to QA (Quality Assurance — the people or team that check the software before it goes further), not to ops, not to the junior who inherits the post-release bugfix job. Above all: do not put defects into production “to fix later.” That is the core of what we are trying to say. It is a common pattern in software delivery — and it is worse with AI than it was before. You ship the package on time; you ask the client to test, knowing the delivery is now so large (AI made volume cheap) that they can really exercise only a fraction of it; yet they carry the responsibility because “the software was there to be tested.” Then bugs land in production by the dozen or the hundred. That is the core of the issue: we accelerate shipping and shift detection downstream; we do not work on prevention. Acceleration is not bad in itself. It is simply not TQM.
  • Just-in-Time (JIT): produce only what is needed, when it is needed, in the amount needed. In software: less speculative inventory of features, branches, and half-done epics that rot. In my view, CI/CD belongs here: many will disagree, but if what you develop does not reach production for weeks or months, you are producing something that is not really needed yet — inventory that sits. Word of caution: that is my reading only, and it does not mean you must rush to production. See jikotei kanketsu above — do not pass defects downstream just to move the needle.
  • Genchi genbutsu: go to the actual place (gemba) and see before you solve. In software: reproduce on the real stack, read the failing test, watch the user path — do not argue from a slide. For me the weight here is also on user stories and flows. Too often we develop knowing only a fraction of the real process. The client has a key role: they must provide those flows and stories so that tests — jidoka again — can catch not only code bugs, but bugs in the flow or in the story itself. That is end-to-end (E2E) automated testing at play, in my opinion: the “actual place” is the journey the user walks, written down and exercised by a gate, not guessed in a meeting or by matching task criteria only.

Key methodologies and tools

  • 5 Whys: ask why until you reach a root cause, not a symptom ticket. A symptom ticket is the surface bug you close so the board looks green — “null check here,” “revert that commit,” “increase the timeout” — without asking why the defect was allowed to reach that place. The fifth why is usually a missing gate, an unclear flow, or a habit of passing work downstream. Fix the ticket alone and the same class of failure returns next sprint.
  • Poka-yoke (mistake-proofing): design the assembly so the error cannot be made — types, schemas, CI checks, forbidden paths in the toolset.
  • Creative idea suggestion system: Toyota’s worker suggestion culture (from 1951 in the usual telling) — millions of small workplace ideas. In software: juniors and seniors both propose process fixes that land, not only hero refactors.
  • Quality circles (QC circles): small groups that meet to analyse operations and build collective problem-solving. In software: the opposite of lone-wolf ego walls. Do not get me wrong: I am not romanticising “teamwork” against people who prefer to work alone. Much of what we call the lone wolf in the last years of Agile delivery is organisational fruit, not a personal lifestyle choice. The familiar micro-unit — one backend, one frontend, one project manager — can meet a client’s need for a supplier on a restricted budget. It also fragments the craft: each person owns a slice, shared problem-solving shrinks, and the “team” becomes three silos that meet on a ticket. I saw the same pattern in construction long before I saw it in IT. The roots are deeper than a developer who “decided” to be a wolf.

Historical milestones (Toyota quality, compressed)

  • 1949: Statistical Quality Control (SQC) enters the story.
  • 1965: Deming Application Prize.
  • 1970: Japan Quality Control Award.

I list these only as orientation. A small company is not Toyota and must not try to become Toyota. What is interesting is how that experience can be ported — principles, not costume. For years we tried to import quality into small and mid-scale firms through ISO certification. The result I have seen most often is more bureaucracy, not more quality. That was a large misconception of what Toyota-style quality meant. Today, in my opinion, a large majority of companies pursue ISO mainly as a ticket to bid on public tenders. That is nowhere near TQM — and frankly has nothing to do with it. The point for us is not to recite prizes. The point is that quality was treated as a company-wide system for decades — not as a slogan and not as optional collateral. Much of the software-development industry later replaced that idea with “move fast”: ship first, discover defects downstream, and call the damage the cost of speed.

Closing

AI did not invent craft. It made something else visible: for years many teams refused the craft that was already available — clean boundaries, tests, readable structure, not shipping junk to the next person — and called that refusal “pragmatism” or “delivery pressure.” When an assistant produces that baseline in minutes, the old excuse collapses: the craft was never impossible; it was often simply not chosen. If we answer only with conductor ego and inflated hourly myths, we protect pride and lose the ladder for juniors. If we answer with TQM — stop the line, do not pass defects, improve every day, measure at the gemba — seniors become quality managers, juniors have a door again, and clients buy fewer expensive surprises instead of theatrical “ten minutes of genius.”

That is an opportunity I would rather not miss.

Written with the help of an AI assistant.