Agile to AI-Native
Transcript
Made automatically from the video's sound, so it may contain mistakes. Click a line to play from there.
Welcome back to part two of our Ways of Working Explainer series. Today, we are jumping straight into the messy reality of how software teams actually operate in practice. So, carrying over from our first explainer, remember the crucial point.
Agile originally rebelled against upfront phase gates. But, as we know, corporate semantic diffusion eventually twisted it into heavy ceremony. We aren't going to rehash the 2001 Snowbird history today, though.
Instead, let's look at the realities on the ground to see how developers, team leads, and product managers can actually get things done. Here is our roadmap for today. First, the core agile triad.
Second, comparing ways of working. Third, flaccid scrum and technical debt. Fourth, opinionated alternatives like ShapeUp. And finally, the Spotify model myth.
The Core Agile Triad. First up, we've got Scrum. You know it, you've probably lived it. It's a lightweight framework using specific accountabilities, events and artifacts to turn a backlog into an increment of value during a time-boxed sprint.
Based on the 2020 Scrum Guide, it operates on three core accountabilities. The product owner, who orders the work, the Scrum Master, who removes impediments, and the developers who actually build the increment. It sets a strict heartbeat through five events, right from the sprint planning down to the retrospective.
And it centers around three key artifacts, each tied to firm commitments to keep the team laser focused. Next up in the triad is Canban. Now, rather than relying on rigid time boxes like Scrum, Canban operates on the empirical physics of queuing.
It uses explicit work in progress or WIP limits to expose downstream bottlenecks and keep work continuously flowing. By capping the number of tasks allowed in any given stage of your workflow, Kanban forces a pool-based system.
You literally cannot start new work until the existing work clears the pipeline. If a column on your board hits its whip limit, the whole team can clearly see the bottleneck and swarm to resolve it, which dramatically reduces all that painful context switching and multitasking.
The final pillar of the triad is extreme programming, or XP. If Scrum gives you the management rituals and Kanban gives you the workflow physics, XP brings the rigorous engineering rules to the table. It ensures internal software quality stays high through automated testing and shared responsibility for the entire code base.
We are talking practices like test-driven development, that classic red-green refactor cycle, pair programming to keep work in progress low, merciless refactoring to keep the code clean, and collective ownership. That means any developer can change any line of code without being a bottleneck, relying on 100% passing unit tests before continuous integration.
Comparing ways of working. When we stack these frameworks side by side, the trade-offs become incredibly clear for developers. For instance, you might choose Kanban for interrupt-driven ops and platform work because it welcomes change mid-cycle if you have the capacity.
Or you might weave in Scrumban to add Canban's whip limits directly to your Scrum sprints. Scrum's rigid cycles are great for product discovery, while XP is absolutely vital for high-risk engineering.
Then you have highly opinionated models like ShapeUp, which uses six-week cycles and bounds work by an appetite rather than an estimate, making it ideal for mature product bets. The big takeaway here, there is no universal silver bullet.
You have to match the framework's physics to your team's actual reality. Flaccid Scrum and technical debt. Flacid Scrum. It describes teams that adopt the management rituals without the extreme programming technical practices needed to maintain internal software quality.
People jump on Scrum because it's popular, right? But because Scrum deliberately omits technical practices, teams often skip them entirely. They do the daily stand-ups, they plan their sprints, but underneath the surface, the code base becomes an absolute mess.
Ever wondered why a seemingly simple feature suddenly takes weeks to build? That mess is exactly what Ward Cunningham's technical debt metaphor explains. It is all about the economics of compounding cruft, where the effort to add new features acts as crippling interest payments.
Just like financial debt, if you rush a feature to meet a sprint goal and ignore the internal quality of the code, you take on technical debt. If you don't take time to pay off the principal by refactoring, that craft compounds.
Soon, a feature that should take four days takes six days. That two-day difference, that is literally the interest you are paying on your technical debt. So running two-week management rituals without rigorous refactoring eventually causes your sprint velocity to flatline.
XP uses automated testing and continuous refactoring to maintain a steady, predictable velocity. Flaccid Scrum teams, burdened by that crippling interest of technical debt, simply stall out.
Without XP practices, the daily scrum degenerates into a manager status core, and the sprint review just becomes an exercise in presenting slideware rather than actual working software. Opinionated alternatives like ShapeUp.
Let's step away from textbook frameworks for a minute and look at Basecamp's shapeup methodology. They argue that backlogs are massive time wasters, preferring instead to evaluate focused, risk-reduced pitches at a betting table.
The creators of ShapeUp believe that having dozens or even hundreds of tasks piling up in a backlog just gives everyone a feeling of being perpetually behind. The time spent constantly reviewing and grooming old ideas prevents teams from actually moving forward.
So, they abandon the backlog entirely in favour of making strategic six-week bets on well-shaped pitches. If a pitch isn't selected, it's dropped. The truly important ideas will naturally come back around.
The rhythm of ShapeUp completely changes the traditional cadence by strictly separating design from execution. It starts with senior members privately shaping the work to de-risk it. Once it's ready, stakeholders take these pitches to the betting table to commit resources.
If selected, the team goes heads down into an uninterrupted six-week build. And I mean uninterrupted. No mid-cycle changes allowed. If they don't finish, a circuit breaker simply cancels the project.
Afterwards, everyone takes a much-needed two-week cooldown to fix bugs and just breathe. The Spotify model myth. Finally, we have to pull back the curtain on one of the most famous yet misunderstood modern operating models.
According to insider Jeremiah Lee and the model's own creators, the famed Spotify squads, tribes, and guilds were largely aspirational PR mythology rather than functional reality. Back in 2012, a white paper outlined this seemingly perfect matrix structure, and the entire tech industry went absolutely wild trying to copy it.
But here is the kicker. As Joachim Sunden, an agile coach at Spotify during that era, plainly stated, they weren't even doing it themselves. It was an ambition that never fully materialized on the ground.
So why shouldn't you cargo cult this model? Well, the matrix management failed because product managers lacked an equivalent engineering counterpart, which led to endless escalations and broken cross-team collaboration.
The system created engineering managers who only handled career development, leaving no single person accountable for a team's actual technical delivery. Plus, the model fixated on team autonomy to such an extreme that it totally sacrificed organizational alignment.
Collaboration was assumed to be a natural skill, but without a common process, overall productivity suffered. Sadly, the PR mythology became so popular externally that it became incredibly difficult to admit failure and change it internally.
Which leaves us with a critical provocation for your own workflows. Since cargo culting someone else's framework rarely works, and there is clearly no textbook silver bullet for software delivery, how does your team actually plan to measure and estimate real world capacity?
We've seen the theories and we've seen the messy realities. We are going to explore how to navigate these exact trade-offs and answer that question in our next explainer, episode 3: Planning and Estimation. Thanks for joining me, and I'll see you in the next one.