Agile Level Set
The why behind how we work, the who we are when we do it, and how we plan together.
Purpose
Why we work this way
I want to make sure we’re all clear on the why behind how we work, because that’s what makes everything else make sense.
Agile replaces prediction loops with learning loops
Where it came from
During the 1990s, a number of lightweight software development methods evolved in reaction to the prevailing heavyweight methods, often referred to collectively as waterfall, that critics described as overly regulated, planned, and micromanaged.
What it does
When we’re asked to deliver in a changing environment, with priorities shifting and dependencies evolving, Agile replaces prediction loops with learning loops. At its core, Agile is a way for teams to continuously inspect what’s happening and adapt based on what we learn, faster than our environment changes.
Agile isn’t a process. It’s a mindset for learning under uncertainty.
Many frameworks, one shared DNA
Same DNA
Scrum, XP, and Kanban live under that umbrella. All of these approaches share the same goal: shorten feedback loops, expose reality sooner, and adapt. We may be using Scrum, Kanban, or SAFe, but we also borrow from other methods and frameworks.
- Lean
- Maximizing value, minimizing waste, empowering people, and continuously improving.
- Systems Thinking
- Seeing how parts interact, not just how they perform individually.
- Theory of Constraints
- Improving the whole system starts with improving its biggest constraint.
- Flow
- How smoothly value moves from idea to customer.
- XP
- Practices like building quality in, incremental change, and a human-centric approach.
Systems Thinking is the lens; Lean and ToC are tools. Flow is what we measure. Agile is how we respond.
A lightweight framework for learning
Founded on empiricism and Lean thinking
Every Scrum event serves one purpose: to make our work transparent so we can inspect it and adapt. The artifacts are the Product Backlog, Sprint Backlog, and Increment. The events each serve empiricism.
Why transparency comes first
Empiricism only works if we make the truth visible, which means sometimes seeing uncomfortable data. That’s why we focus first on transparency. It’s impossible to adapt if we can’t see reality.
Built for where requirements and technology both change
Matching approach to complexity
The original Stacey Matrix was used to determine a management approach based on project type, ranging from command and control, to consensus, to organic and adaptive, to experimentation and learning. We’re in a space where requirements and technology both change. That’s exactly where Scrum shines.
Smaller, better plans more often
In complex work, we can’t predict everything. Scrum gives us a rhythm to inspect what’s emerging and adapt intelligently. It isn’t about replacing planning; it’s about making smaller, better-informed plans more often.
Scrum gives us structure for doing what Agile promises: continuous learning in short cycles.
Empiricism in motion
Knowledge comes from experience
Empiricism asserts that knowledge comes from experience and from making decisions based on what is observed. Scrum is empiricism in motion. Each Sprint is a full inspect-and-adapt cycle, which is why it mirrors PDCA, the Deming Wheel.
A note on Deming
W. Edwards Deming is the father of quality control. After WWII he advised Japanese business leaders on management, and is credited with revolutionizing Japan’s industry. Taiichi Ohno built the Toyota Production System from Deming’s teachings, and Lean is a set of tools derived from it. Scrum is built on the same learning cycle that powered modern quality and scientific management.
Nested feedback loops
We don’t plan less; we plan more often, with fresher information. Scrum runs an inner loop, the Daily Scrum, where we inspect and adapt the plan each day, and an outer loop, the Sprint, where we inspect and adapt the whole system. PDCA improves process; Scrum applies it to both process and product.
| PDCA | Scrum equivalent | Focus | Correct the misunderstanding |
|---|---|---|---|
| Plan | Sprint Planning | Define intent: Sprint Goal, forecast, and a plan to get there. | Planning isn’t predicting everything; it’s setting direction under uncertainty. |
| Do | Sprint Execution & Daily Scrum | Deliver increments toward the goal while inspecting progress daily. | Execution isn’t heads-down work; it’s adaptive doing guided by inspection. |
| Check | Sprint Review & Retrospective | Inspect the product (Review) and the process (Retro) for evidence. | Check isn’t judging performance; it’s discovering truth. |
| Act | Apply learnings | Adapt backlog, practices, and Definition of Done. | Acting isn’t just fixing issues; it’s intentionally changing behavior or direction. |
Everything we do in Scrum — every event, artifact, and conversation — exists to help us inspect reality and adapt toward better outcomes.
That’s what keeps Scrum alive: not process compliance, but continuous learning through inspect and adapt.
People
Who we are when we do it
Last time we talked about why we work this way. This is about who we are when we do it: the behaviors and relationships that make Scrum actually work. This is the Agile value, “people over process.”
Behavior matters more than any rule
Values define behavior
These values define our behavior more than any rule. When they’re weak, we hide problems. When they’re strong, we surface truth early, and the metrics take care of themselves.
- Courage
- → Transparency
- Openness
- → Inspection
- Commitment & Focus
- → Adaptation
- Respect
- → Enables all of them
Each role owns a dimension of value
Accountability is ownership, not task lists
Each role serves the same purpose: delivering value transparently. Accountability means owning the outcome, not doing every task. The Product Owner is accountable for maximizing value, the Developers for creating it, and the Scrum Master for improving how we deliver it. The Scrum Master’s job is to protect integrity, not optics.
What about project management in Scrum?
Scrum doesn’t eliminate project management; it makes it everyone’s business. It’s a shared responsibility distributed across the three roles:
- The Product Owner manages scope, priorities, and stakeholder expectations.
- The Developers manage the day-to-day work, forecasting, tracking progress, and adapting plans.
- The Scrum Master manages the framework itself, making sure the process reveals truth rather than hides it.
In traditional terms, the project-management activities are still here. They’re just divided so that ownership aligns with accountability, not hierarchy.
Owning the how, inside clear boundaries
What autonomy actually means
Autonomy doesn’t mean doing whatever we want. It means owning how we achieve shared outcomes, inside clear boundaries and with visible accountability. It shifts the mindset from “leadership tells us what to do” to “leadership gives us context and goals, and we decide how to get there.”
Who owns what
Leadership defines the why and what: vision, Product Goal, and constraints. The team owns the how: approach, estimation, flow, and commitments. Transparency and trust are the bridges between them.
The more we demonstrate transparency and reliability, the wider that space becomes. Autonomy grows with trust.
A spiral, not a checkbox
The reinforcing cycle
The spiral represents continuous growth; it’s not a straight line. Openness invites trust: when people share honestly and are met with curiosity, trust grows. Trust enables openness: the safer people feel, the earlier they speak up about risks or mistakes. Together they drive performance, because information flows freely.
It can reverse
If openness or trust break down, for instance when honesty is punished, the spiral reverses: trust erodes, communication slows, and progress stalls.
A good signal of trust is how quickly bad news travels. In high-trust teams, problems move faster than blame.
Storming isn’t dysfunction. It’s the team becoming real.
How teams evolve
- Forming — polite and uncertain, testing boundaries.
- Storming — conflict surfaces as people challenge assumptions.
- Norming — the team establishes working agreements and shared expectations.
- Performing — trust and clarity let the team self-manage smoothly.
The Scrum Master meets the team where it is
Each stage asks something different: directing by creating clarity while forming, coaching through conflict while storming, empowering the team to own its rhythm while norming, and delegating while performing. Delegating doesn’t mean stepping away; it means there’s enough trust for more ownership to live inside the team.
Our goal isn’t to avoid conflict; it’s to reach the kind of trust where conflict is productive.
Trust is the foundation everything stacks on
Five questions to ask ourselves
- Trust
- Do we feel safe to say “I don’t know”?
- Conflict
- Can we challenge ideas without it feeling personal?
- Commitment
- Do we leave meetings clear on direction?
- Accountability
- Do we hold peers to agreements?
- Results
- Do we measure what matters, not just what’s easy?
Healthy teams lean into constructive conflict, because they trust each other enough to disagree productively.
Transparency and empiricism only work when trust is strong. It’s the foundation that makes everything else possible.
Planning
SAFe PI Planning, the team’s way
How we turn a backlog and a goal into a committed plan together. “There is no magic in SAFe… except maybe for PI Planning.” — Dean Leffingwell
What we walk out of PI Planning with
The secret of getting ahead is getting started. — Anonymous
- PI Objectives
- SMART business and technical goals for the increment.
- Sprint Plans
- Stories assigned to Sprint backlogs in Jira.
- Dependencies
- Discussed with other teams and tracked in Jira.
- Program Board
- Dependencies, epics, and milestones, visualized.
- Risks
- Run through the ROAM board, then logged in Jira.
- Confidence Vote
- A draft-plan vote and a final-plan vote.
- PI Retrospective
- What to improve before the next planning event.
Do the homework before the event
It is always wise to look ahead, but difficult to look further than you can see. — Winston Churchill
- Epics arrive early
- The product team gets epics to the Product Owner ahead of the IP iteration.
- PO previews with the team
- Walk through what’s coming so nothing is a surprise on day one.
- PO drafts initial stories
- A starting point the team can react to and refine.
- Team refines & estimates
- During the first week of the IP iteration, the team questions, splits, adds, and gives initial estimates.
Walking in prepared is what makes two days of planning enough.
Two days, from draft to commitment
Day one ends in a draft
The team discusses leftover stories, notes dependencies and risks, drafts PI Objectives, plans Sprints to the target load, updates the Program Board, and takes a confidence vote on the draft. The Scrum Master and Product Owner then present the draft to management for feedback.
Day two ends in a commitment
The team applies the feedback, finalizes objectives, updates the board, ROAMs the risks, and takes a final confidence vote. Then the SM and PO present the final plan, and the team runs a PI Retrospective.
Planning is a quest for value. — Mike Cohn
A shared language for the increment
What they’re for
PI Objectives summarize a team’s business and technical goals for the increment. They give business and technology stakeholders a common language, and create near-term focus and vision.
Committed vs uncommitted
Uncommitted objectives (once called “stretch”) are planned, but deliberately left out of the commitment, so they protect the plan rather than inflate it.
Be fixed on the vision, but flexible on the journey. — Jeff Bezos
Plan to a target load, not to the brim
How we size capacity
One point for each day in the Sprint. Subtract two points for meetings, and one more for every planned day out of office. A one-point story takes about half a day to code and half a day to test.
Why we hold back
We coach teams not to exceed the target percentage of capacity, so there’s room to absorb what we learn mid-PI. During each Sprint Planning, we adjust the plan to that Sprint’s real capacity.
Stable velocity. Sustainable pace. — Mike Cottmeyer
A visual radiator of how the work connects
What it shows
Epic delivery dates, dependencies, and milestones, all in one view. As the team breaks down epics, it discovers and calls out dependencies.
How we use it
We work with other teams to discuss and coordinate those dependencies, then add them to the board so the whole program can see them.
Just because you make a good plan doesn’t mean that’s what’s gonna happen. — Taylor Swift
Name every risk, then give it a home
Identify and categorize
We surface any risk to a team meeting its objectives and sort each one into the ROAM board, so none of them stay vague or unowned.
- Resolved
- The team agrees it’s no longer a concern.
- Owned
- Someone takes it on when it can’t be resolved during planning.
- Accepted
- A fact or possibility we understand and live with.
- Mitigated
- We have a plan to reduce its impact.
Everyone has a plan until they get punched in the mouth. — Mike Tyson
A signal that the plan is good enough to commit to
How the vote works
Each person shows zero to five fingers using the “Fist to Five” scale. Three or higher signals consensus. Anyone voting below three gets heard, and we adjust the plan if we need to.
It’s a signal, not a metric
We don’t track the number or treat it as a metric or a score. It exists to answer one question: is the planning good enough that the team can commit? If not, we keep working the plan until it is.
Plans are worthless, but planning is everything. — Dwight Eisenhower
Present, adjust, commit, and improve
The important thing is not your process. The important thing is your process for improving your process. — Henrik Kniberg
- Present the draft
- SM and PO take the draft plan to Dev and QA managers and directors.
- Show the key outputs
- Capacity and load, PI Objectives, dependencies and risks, and the confidence score.
- Get feedback & approval
- Adjust the plan, then present the final version for sign-off.
- Retrospect
- Capture what went well, what didn’t, and what to do better next time.
Resources
Everything referenced across the three parts, grouped by section.
Purpose
- Agile Manifesto https://agilemanifesto.org↗
- Scrum https://agilemechanics.com/hubs/methodologies/scrum.html↗
- Adapted Stacey Matrix https://agilelaws.com/adapted-stacey-matrix.html↗
- PDCA / Deming Wheel https://agilelaws.com/deming-wheel.html↗
- Agile Field Guide https://agilefieldguide.com↗
- Agile Mind Patterns https://agilemindpatterns.com↗
- Agile Laws https://agilelaws.com↗
People
- Scrum Guide https://scrumguides.org/scrum-guide.html↗
- Psychological Safety https://agilemindpatterns.com/core-agile-mind-patterns/psychological-safety-as-a-thought-pattern.html↗
- Tuckman’s Ladder https://agilelaws.com/tuckmans-ladder.html↗
- The 5 Dysfunctions of a Team https://agilelaws.com/five-dysfunctions-of-a-team.html↗
Planning
- Scaled Agile — PI Planning https://scaledagileframework.com/pi-planning/↗
- SAFe PI Objectives https://scaledagileframework.com/pi-objectives/↗
- Program Board https://scaledagileframework.com/program-board/↗
- ROAM Risks https://scaledagileframework.com/risk-roaming/↗
- EasyRetro https://easyretro.io↗