TL;DR
- Agile is having a crisis, driven by modern work realities, over-engineered systems, and the difficulty of coordinating across multiple teams.
- Get your org back into an Agile groove with lightweight async principles and techniques.
- Use automation and AI to supercharge your async Agile implementation.
Agile in crisis
Agile, as in the capital-A methodology, is having an existential crisis at the moment.
Predictability is and always has been the key selling point for Agile and all of the frameworks, processes, certifications, and systems that followed. Understand the problem, organize this way, do these things, and great software routinely comes out the other end in small but valuable and frequent increments. Yay, everyone from the bosses to the developers are happy. That’s how it got so popular and almost ubiquitous.
But many “Agile” orgs simply aren’t delivering value–working software–in a predictable way anymore.
Sure, teams manage to check off the ceremonies with regular stand-ups and retros, or move the right number of story points through a sprint, but that’s not the same thing as shipping working software in a predictable fashion that you can build a business around.
Framework checkpoints and predictability used to correlate, but now they don’t.
This is not just my opinion based on anecdotal evidence (although I’ve gathered plenty of that in my day-to-day work at Steady). The latest State of Agile report paints a dismal picture, too: only 11% of companies that use Agile as part of their SDLC report it’s going “very well.” Just 33% say “somewhat well.”
Yikes. And the bigger the org, the worse it’s going–medium and large companies are 56% more likely to say it’s “not working well.”
So … what’s going on?
The Agile manifesto and principles are almost a quarter-century old but actually hold up quite well.
The core of the matter is this: making software collaboratively is a highly subjective endeavor; you can skin the cat in infinite ways at every turn. That has not changed since the ski lodge gathering. Agile is still the right direction for orgs to craft solutions to customer problems within uncertain constraints, both external and internal. It remains superior to spec-based project management paradigms in this regard.
No, it’s not Agile as a methodology, it’s Agile implementations that aren’t keeping up with the times, both custom and codified (Scrum, Kanban, SAFe, etc).
In particular, I see three overlapping factors at the heart of the current Agile implementation malaise:
Modern work realities
First, the nature of tech work has fundamentally changed. We’re no longer pinned to a specific time or place for work. The pandemic accelerated the shift to distributed teams, flexible schedules, and hybrid work arrangements. Even for those back in offices full-time, the way we collaborate has been irreversibly altered.
Video calls have become the default, but they come with their own set of challenges. While they enable face-to-face interaction across distances, they’ve also normalized a culture of distraction. It’s all too easy to multitask during a Zoom meeting, with Slack, email, and other work (or non-work) apps just a click away. This divided attention undermines the very collaboration these tools are meant to facilitate.
In particular, meetings crucial for coordination and alignment, like daily stand-ups or the scrum-of-scrums, have become lengthy, piecemeal, and ineffective affairs.
People are checking out during Agile meetings.
Over-engineered systems
Second, we’ve painted ourselves into a corner by over-engineering our processes and tools. In an attempt to make Agile more “scalable” or “enterprise-ready,” we’ve broken down workflows into increasingly granular steps that remove the very flexibility that allowed teams to self-organize as outlined in the manifesto. And our tools–ticket systems, wikis, SCM, etc–fragment context into tiny, disconnected bits of information scattered across multiple platforms.
So even when Agile self-organization is the intent, everyone has to puzzle together the context required to make that possible, mostly by throwing up their hands, interrupting someone elso, or having yet another meeting.
Cross-team coordination
Third, as organizations grow and products become more complex, we’re faced with the thorny challenge of coordinating dependencies across multiple teams. Each team often operates in its own silo, with its own data, processes, and stack of tools. The critical information needed to resolve dependencies gets buried beneath layers of team-specific context, only to be surfaced topically in scrum-of-scrums gatherings or via burdensome “asks.”
(It’s worth noting this is not a new problem–the Agile frameworks built for big orgs have never really cracked this nut.)
Stuck in the alignment trap
The consequence is that these factors converge to create “the alignment trap.” Organizations find themselves caught between two unworkable extremes:
- Too many meetings in a desperate attempt to gather context and stay aligned. This approach saps productivity and leaves little time for actual work.
- Silo-ed efforts because of insufficient context, leading teams to work in the wrong direction or duplicate efforts.
Both scenarios obliterate the predictability that Agile promises to deliver. We end up with teams that are either constantly interrupted or chronically misaligned – neither of which leads to the consistent delivery of value.
Structured async to right the ship
So, how do we course-correct? The answer is to embrace structured asynchronous communication, using a an open-source set of principles called Continuous Coordination.
This isn’t just about replacing synchronous communication with Slack messages or emails. It’s about reimagining how we coordinate our Agile work in a way that’s flexible, scalable, and accounts for modern work realities.
The key is to focus on principles rather than rigid processes–agility. In other words, using an approach that can adapt to the unique needs of an organization while still providing enough structure to keep teams aligned and productive.
Here’s how Continuous Coordination works:
Create tight, team-level async communication loops
At the team level, we introduce the concept of a daily(-ish) async communication loop. This replaces the traditional daily stand-up with an asynchronous, written check-in. Team members share:
- Their intentions for the day (or next couple of days)
- What they accomplished since the last check-in
- Any blockers or areas where they need help
This provides the necessary context for coordination without the interruption of a daily meeting. It also creates a written record that’s easy to reference and allows for more thoughtful responses.
Create wide, org-level async communication loops
For cross-team coordination, we implement a lower frequency, cross-team async loop. This loop centers around creating communication anchor points for initiatives that span multiple teams, or serve as longer term objectives within a team. Key stakeholders regularly update the status, challenges, and next steps for these larger goals, with links to relevant information with a team’s tools or knowledge stores. Think of it as an internal blog for a team or cross-team objective.
This approach ensures that critical information doesn’t get lost in the noise of day-to-day tasks, providing a common mechanism for surfacing and addressing cross-team dependencies. Scrum-of-scrums without the meeting.
Additional principles of this structured async approach–Continuous Coordination–include:
- Emphasizing written communication for important decisions and discussions
- Creating a single source of truth for key information
- Reserving precious meeting hours for focused collaboration time and complex problem solving
- Regularly pruning and refining processes to avoid unnecessary complexity
Automate with Steady
While structured async coordination can dramatically improve your Agile processes, we can take it even further by automating the loops and distilling context with AI. Uncoincidentally, this is what we’re building at Steady.
Running in the background
Steady runs in the background, constantly gathering context from all the tools, teams, and people across your organization and automating the communication loops. It’s not another process to follow – it’s an umbrella layer that with works with your tools to supercharge Agile workflows.
Usually people have to pull information out of tools and or knowledge silos on other teams to get the context they need. Steady does that for you, automatically pushing tailored summaries to the right people at the right time.
Mixing hard and soft data
Steady doesn’t just look at metrics like story points or velocity, you’ve already got plenty of tooling for that. It distills the qualitative information found in human-generated updates with the activity integrations. This holistic approach provides a much richer understanding of your team’s work and progress.
AI to highlight
The real magic happens when we apply AI to this wealth of information. But it’s not just about blindly summarizing data. Steady uses AI to distill the most relevant insights and highlight the information that matters most to each team member.
This means everyone gets the context they need, tailored to their role and current focus. Developers see relevant technical decisions and dependencies. Product managers get insights into user feedback and feature progress. Leaders gain visibility into overall project health and potential risks.
I use Steady everyday to run Steady and keep our company both agile and Agile. I’m never going back. Here’s what you see when you sign in–tailored summarizes, live goal status, and nudges to contribute:
Onward
Every org is different. The best Agile implementation is the one that works.
The path forward isn’t about abandoning Agile principles–it’s about practically applying them a way that fits how we actually work today: flexibly, with lots of tech to support our efforts. By applying structured async coordination and levering AI and automation, you can supercharge your team’s effectiveness and get back to the predictable, value-driven delivery cadence that Agile always promised.
