Scrum, Kanban, and XP in Practice
Transcript
Made automatically from the audio, so it may contain mistakes. Click a line to play from there.
Imagine a team that you know hits every single scrum ceremony on the calendar.
Right, like they never have a statically stand up.
Exactly. Their sprint planning is meticulous. The retrospectives are scheduled like absolute clockwork. But if you look at their board, 14 tickets are just piled up in the in-review column.
Oh yeah, the total traffic jack.
Yeah, and there is no coherent sprint goal at all. It's just this like grab bag of unrelated tickets. And the developers are practically begging leadership for a refactoring sprint because nobody wrote any tests.
Right. The code base is basically a house of cards at that point.
Totally.
I mean, that is a painfully familiar picture for so many teams. It's this exact scenario that Martin Fowler calls flaccid scrum.
Flaccid scrum.
Yeah. It is what happens when teams eagerly adopt all the project management processes, but they completely ignore internal software quality. So they end up taking on crippling technical debt.
Right.
And their scrum just goes, well, weak at the knees.
Welcome to Deep Dive Episode 2 of Ways of Working from Agile to AI native. Our mission today is to compare how Scrum, Kanban, and Extreme Programming, or XP, actually run in practice.
Along with some real-world hybrids, right?
Yes, like Scrum Bon, ShapeUp, and the Spotify model. And we're doing this specifically for you, the developers, the engineering leads, and the PMs who actually have to make this stuff work on Monday morning.
To set the stage, we have a great stack of sources today. We're pulling from the 2020 Scrum Guide, the Conban Guides, Martin Fowler's essays, Basecamp's ShapeUp, and Jeremiah Lee's critique of the Spotify model.
Okay, let's unpack this. To quickly recap our last deep dive, you already know about Waterfall's failure modes, the 2001 Snowbird Agile Manifesto, and the dangers of semantic diffusion.
Right. That's all covered.
And just a quick boundary, we are absolutely not discussing story point math, Monte Carlo forecasting, or roadmaps today.
Oh, thank goodness.
Yeah. We're saving all of that for episode three. Today is purely about the actual workflow matchanics.
So to understand why teams fall into that flaccid scrum trap, we have to contrast how frameworks are supposed to work mechanically versus how they, you know, devolve in reality.
Right. Let's look at the 2020 Scrum Guide first.
Yeah. So the fundamental unit of Scrum is supposed to be a small cross-functional team without any sub hierarchies. You just have three accountabilities.
The Scrum Master, the product owner, and the developers.
Exactly. And the ideal is that a true daily scrum is just a 15-minute developer replanning huddle. It's aimed strictly at a unified sprint goal.
But in reality, I mean we've all seen it, it so often devolves into this painful manager status theater.
Oh, absolutely.
It's just a ticket grab bag where everyone says, yesterday I did ticket A, today I'm doing ticket B.
Right. Because people are just trying to prove they're busy instead of actually swarming a goal.
So if sprints just become these artificial pressure cookers, why not just get rid of the sprint entirely?
Well, that's exactly the pivot to Kanban. Conban's active flow management and queuing mechanics are entirely different.
You're not working in two week boxes anymore.
No. The structural engine of Kanban is explicit whip limits, work in progress limits.
I always think of whip limits like the bouncer at a really exclusive club. It's strictly one out, one in.
That's a great analogy.
Because if the in review column hits its whip limit, say it's three tickets, the board essentially turns red.
Yeah. The system says stop.
Right. And the team must swarm to clear that PR bottleneck before they're allowed to start any new work.
Stop starting and start finishing. But here's the thing. Scrum tells you how to manage, but it doesn't tell you how to write good code.
There's where it gets really interesting. Scrum tells you how to manage, but XP tells you how to code.
Exactly. XP's technical habits are the actual structural engine that keeps iterative teams fast. We're talking about the red green refactor TDD cycle.
Test driven development.
Right, and you've got driver navigator or ping pong pair programming, merciless refactoring, and collective code ownership.
So everyone owns the code together.
Right. What's fascinating here is that without XP's technical practices, the iterative delivery demanded by Scrum is just impossible to sustain.
The code just rots. But wait, I mean, let's be candid about the trade-offs here. Isn't forcing two developers to share a keyboard all day a fast track to burnout?
Oh, for sure. Pair programming absolutely causes pairing fatigue. It is exhausting and it requires intense vulnerability.
You're basically coding out loud all day.
Yeah. But you have to weigh that against the benefit. It is the ultimate silver bullet for cutting async PR latency and breaking down knowledge silos.
Because the review is happening in real time.
Exactly. You don't wait three days for a senior engineer to tell you your architecture's wrong.
Right, which brings us to technical debt. I mean, Fowler's piece talks about Word Cunningham's true meaning of technical debt.
Yeah, and this is so important because it's usually misunderstood. Cunningham said it's not just writing bad code because you're rushing.
It's not just being sloppy.
No. It's actually taking on debt to learn about the domain. You write code based on what you understand today. Tomorrow you understand more.
And that gap is the debt.
Exactly. And that debt must be repaid via refactoring, or your sprints will eventually go totally weak at the knees.
Okay, so if these mechanics are so great, why don't teams just combine them perfectly?
Because every practice has a distinct human or organizational trade-off. We start getting into practitioner opinions now rather than just strict queuing mechanics.
Right. Real world hybrids. Let's talk about Scrum Bun.
Yeah, so Scrum Bon is pretty much the de facto default for a lot of teams. It blends the planning cadence of Scrum with the whip limits of Kanban.
Which is perfect for high interrupt environments, right? Like a platform team dealing with life bugs.
Exactly. You need the flow to handle the bugs, but you still want the planning rhythm for stakeholders.
Okay, what about ShapeUp? Because Basecamp's Ryan Singer basically says throw out the backlog entirely.
Yeah, shapeup is super opinionated.
They swap backlogs for these six-week appetite bets.
Which means they don't ask how long it takes, they ask how much time they're willing to spend on it.
Right.
And they use decentralized lists instead of a giant Jira board. But the craziest part is the circuit breaker.
Oh, yeah, this is brutal. It is.
If a project isn't shipped in six weeks, it doesn't bleed into the next cycle. By default, they just kill the project.
It forces them to actually ship. But I mean, that requires a ton of autonomy, which brings up the 2012 Spotify model that literally every tech company tried to copy.
Oh, the famous Spotify model. If we connect this to the bigger picture, Jeremiah Lee has a brilliant insider breakdown of this.
Right, because it was basically just a bunch of catchy names, right?
Yeah, they were cargo culting the terminology. Squads, tribes, guilds. They renamed a standard matrix management structure to sound like a video game.
But it didn't actually magically grant teams true autonomy.
No. It didn't fix any of their cross-team dependencies at all. It was just window dressing.
So what does this all mean for you? If someone is listening to this right now and looking at a totally blocked board.
I'd say there are three actionable moves you can make tomorrow. First, and remember, don't treat any of this as a universal religion, but first, cap your whip limits.
Specifically enforce a strict limit on your code review column, right?
Exactly. Force the team to finish work rather than just constantly starting new tickets.
Love that. What's the second move?
Second, enforce a real definition of done. Borrow those XP habits like TDD and collective code ownership.
So you ensure technical quality actually prevents that flaccid scrum.
Yes. And third, match your cadence to your interrupt rate. If your team handles constant urgent bugs, you need to ditch rigid scrum sprints.
Move to Kanbon or Scrumbone.
Exactly. Go for flow.
Awesome. Now that we have our workflow engines built, how do we predict when anything will actually be done? Next time on our deep dive, we are tackling episode three, planning and estimation.
I can't wait for that one. But, you know, this raises an important question before we go.
Oh.
If Agile frameworks were originally designed to maximize the flow of completed code, what happens when AI allows us to generate code instantly?
Oh wow, that completely changes the bottleneck.
Right. Perhaps the ultimate metric of a team won't be how fast tickets move across a board. Maybe it'll be how quickly they can use these collaborative frameworks to safely invalidate a bad idea before a single line of AI code is ever generated.
That is a wild thought to leave on. Invalidating bad ideas faster. Well, lots to think about for Monday morning. Catch you all in the next deep dive.