Agile and Kanban came into software dev as practical escapes from rigid waterfall hell — pulling ideas straight from Lean manufacturing and Toyota Production System (TPS). The promise: faster feedback, slashed waste, better quality.
But in most IT shops today? Agile has turned into empty
rituals:
- Stand-ups with zero real learning
- Kanban boards showing piles of WIP but no actual flow
- Retros that spit out "insights" nobody ever acts on
The mechanics are there. The quality mindset that made them powerful? Long gone.
Look at Agile through real industrial quality lenses (manufacturing, aviation, energy, regulated fintech) and the cracks show instantly.
Agile as Ritual vs. Agile as a System
In a factory, a Kanban board isn't decoration — it's a hard control system:
- Regulates flow
- Exposes bottlenecks
- Signals abnormalities immediately
Meetings aren't ceremonies; they're decision gates backed by measurable system data.
In software? Too many teams run
performance theater:
- Cards slide across boards with no WIP limits enforced
- Stand-ups = "what I did yesterday" reports instead of system health checks
- Retros = therapy sessions with no institutional change
- Quality gets dumped on QA instead of built into every management decision
Result: lots of motion, zero progress.
Industrial truth: if a ritual doesn't alter
system behavior, it's not a process — it's just a bad habit.
Quality Is a Management Responsibility, Not a Role
W. Edwards Deming hammered this decades ago:
"Quality cannot be inspected into a product."
Quality comes from management choices — design, flow, incentives, feedback loops — not downstream inspection.
Yet most IT orgs still do the handoff dance:
- Devs throw code over the wall
- QA catches defects
- Ops stabilizes the mess
Real industrial systems don't tolerate this fragmentation. Recurring defects? Root cause almost always traces back to management: stupid throughput targets, overloaded teams, vague standards, broken incentives.
When quality = "QA's job", management is quietly admitting they're not accountable for outcomes. No amount of Agile ceremonies fixes structural failure.
Root Cause Analysis Over Symptom Patching
Industries that can't afford failure (power plants, aerospace, payments) don't just fix symptoms — they hunt causes.
RCA, FMEA, blameless post-mortems are automatic reflexes. Repeat failure = design/system flaw, not "human error".
Software teams? We:
- Patch the same bugs forever without touching architecture
- Miss sprint goals and just "try harder next time"
- Add more meetings to fix problems caused by too much WIP
Industrial reframing: If the team chronically overcommits and fails, don't ask "Why didn't they execute?" Ask:
"Why does the system permit chronic overcommitment?"
Pull Systems, Not Activity Porn
True Kanban = ruthless pull. Work only starts when there's real downstream capacity. Inventory = risk, not safety blanket.
In software Kanban? Boards often become giant to-do lists:
- Dozens of items "in progress"
- Visible chaos mistaken for transparency
Industrial logic is brutal: excess WIP inflates lead time, hides defects, kills predictability.
A pull system without enforced WIP limits isn't pull — it's push in disguise.
High-reliability software teams (fintech, embedded, etc.) enforce:
- Strict WIP caps
- Lead time + variability metrics (not just velocity BS)
- Interruptions treated as systemic failures to eliminate
Outcome: not slower — more
reliable delivery.
Waste Reduction — It Translates Perfectly to Knowledge Work
Lean's 7 wastes map directly:
- Overproduction → features nobody uses
- Waiting → devs blocked on reviews/approvals/unclear specs
- Handoffs → excessive team silos
- Rework → late feedback + unclear standards
Agile rituals by themselves don't kill waste. Only system-level redesign does.
Biggest productivity wins in software usually come from removing structural friction created by bad management decisions — not from "coding faster".
Reclaiming Agile the Industrial Way
You don't have to ditch Agile. You have to rescue it from LARPing.
Treat Agile like a
management system, not a team-level checklist:
- Boards → actual flow control tools
- Meetings → real decision forums
- Metrics → signals that trigger system redesign
- Quality → leadership obligation, not a downstream role
Hard pill: Agile fails hardest exactly where management accountability is weakest.
Rituals stick around because they're easy to fake. Real system thinking is hard — it forces leaders to own how their decisions f**k up outcomes.
Industry learned this lesson the hard way decades ago.
Software is still catching up.
Thoughts? Flame away or share war stories from your orgs.
![[Image: technology.gif]](https://i.postimg.cc/44pnRpN5/technology.gif)
