The “agile is dead” argument appears on a reliable cycle, usually authored by someone who spent years watching organizations adopt the ceremonies, terminology, and org charts of agile while preserving the planning assumptions, reporting structures, and risk culture of waterfall. The frustration is legitimate. The conclusion is wrong. What failed in most organizations was not agile. It was a management consulting product that appropriated agile vocabulary while systematically removing the practices that give agile its value.

Continuous delivery is typically categorized as a DevOps or engineering operations practice: build pipelines, automated testing, deployment automation, infrastructure as code. This categorization is accurate but incomplete in a way that matters. Continuous delivery is also the technical prerequisite for agile development to function as intended, and teams that treat it as an infrastructure concern rather than a delivery discipline tend to develop a subtle dysfunction in their sprint practice.

Most agile teams have a definition of done. Fewer have a definition of ready. The asymmetry is understandable — done is where accountability lives, where the increment is evaluated, where quality is enforced — but the absence of a ready definition pushes unresolved questions into the sprint, where they are more expensive to answer. A definition of ready is an agreement about what a story must have before it can be pulled into a sprint.

The fixed-price contract is built on a specific assumption: that the scope of the work can be defined in advance with enough precision to price it accurately. The agile development model is built on a specific observation: that software requirements are not fully knowable in advance, and that attempting to define them completely before development begins produces worse outcomes than defining them incrementally in response to what is learned during development.

The debate over whether a team should use kanban or scrum is often a proxy for a different and more useful question: does this team’s work arrive in predictable batches or as a continuous flow? Scrum is designed for the former. Kanban is designed for the latter. The choice follows from the nature of the work, not from a preference for ceremonies or a dislike of story points. Scrum works well when a team can define discrete deliverables, plan a fixed amount of work for a fixed period, and evaluate progress at the end of an iteration.

The scaling agile industry — SAFe, LeSS, Nexus, Scrum@Scale, and their variants — exists to solve a real problem: how do you coordinate multiple agile teams working toward a shared product without recreating waterfall planning at the portfolio level? The problem is genuine. The solution is frequently applied to organizations that do not have it. The typical trigger for a scaling framework adoption is not coordination failure between teams — it is discomfort at the leadership level with the absence of a visible, organization-wide plan.

Planning poker is an estimation technique in which team members simultaneously reveal their estimates for a story, then discuss discrepancies before converging on a number. The standard explanation for why it works is that simultaneous reveal prevents anchoring — no one’s estimate influences others before they have formed their own. This is true and not the main reason the technique is valuable. The main reason planning poker works is that it makes disagreement visible.

When agile teams moved to remote work, the common concern was whether the ceremonies would survive the transition. Would sprint planning work over video? Could retrospectives produce candor without physical presence? Would the daily standup maintain its discipline when the team was distributed across time zones? These concerns were largely misplaced. The ceremonies adapted. Video-based sprint planning, while less fluid than in-person, functions well enough with the right tools and facilitation.

For most of software’s history, vague requirements were expensive but survivable. A developer who received an underspecified ticket could ask a question, make a reasonable inference, or build a small prototype and get feedback. The cost of ambiguity was absorbed in back-and-forth, rework, and the gradual clarification that happened naturally when humans were iterating together. AI-assisted development has changed the economics of ambiguity in a way that most teams have not fully reckoned with.

The retrospective is the most important ceremony in the sprint cycle and the one most commonly reduced to ritual. Teams go through the motions — what went well, what didn’t, what to improve — produce a list of action items, and proceed to the next sprint having changed nothing. The list sits in a document somewhere. The problems repeat. This failure mode is so common that many experienced practitioners have concluded retrospectives do not work.

The large story is one of the most reliable predictors of sprint failure. A story that spans more than half a sprint occupies the team’s attention, resists review, and tends to arrive at the sprint boundary in a state of near-done that creates exactly the kind of work-in-progress debt that sprints are designed to prevent. Teams know this. They continue to carry large stories because splitting them well is genuinely difficult and the techniques for doing it are not intuitive.

Technical debt in most agile teams exists in two places: in the codebase, where it slows down every sprint without appearing in any sprint report, and in informal conversations between developers, where it is acknowledged but never prioritized. This arrangement persists because engineers are reluctant to burden the product owner with implementation concerns, and product owners are reluctant to prioritize work that has no visible user-facing outcome. The debt accumulates. The sprints slow down.

The #NoEstimates movement emerged from a simple observation: software estimation is expensive, frequently inaccurate, and the act of producing an estimate often shapes behavior in ways that undermine the purpose of the estimate. Teams that spend significant time debating whether a story is a three or a five are investing real effort in a number that will be wrong and then used to evaluate their performance. The question the movement raises is whether that investment produces enough value to justify the cost.

The definition of done is one of the more underrated concepts in agile practice. A shared, explicit, team-level agreement on what it means for a story to be complete is the mechanism that prevents the slow accumulation of almost-done work that eventually freezes a sprint. Without it, done means different things to different people, and the gap is always paid for later. AI-assisted development introduces a new category of questions that most teams’ definitions of done do not yet address.

The product owner in scrum is responsible for maximizing the value of the product resulting from the team’s work. The Scrum Guide is admirably concise on this point and deliberately silent on how it is achieved, because how it is achieved depends entirely on the product, the organization, and the market. What the definition does not convey is the difficulty of the role when it is done correctly. The product owner must maintain a clear product vision, own a prioritized backlog that reflects that vision, be available to the team for clarification during the sprint, and make decisions about scope and trade-offs in real time.

The scrum master role is routinely reduced to meeting facilitation and impediment tracking. The scrum master runs the standups, schedules the retrospectives, maintains the board, and removes blockers that the team surfaces. Done well, this produces smooth ceremonies and a team that is not visibly impeded. It does not produce the organizational change that agile practice requires to sustain value over time. The Scrum Guide defines the scrum master as responsible for the team’s effectiveness and for helping everyone understand scrum theory and practice, both within the team and across the organization.

The sprint goal is a single objective that the team commits to achieving through the sprint. It gives the sprint coherence — a reason the sprint backlog is the particular collection of items it is, rather than an assortment of the next highest-priority tickets. It gives the team a basis for decision-making during the sprint when unexpected complexity arises. And it gives stakeholders something to understand about what the sprint is for beyond a list of story numbers.

The user story format — as a user, I want, so that — was not designed to specify behavior. It was designed to prompt a conversation about behavior. The distinction matters because teams that treat the card as the requirement skip the conversation, and the conversation is where the value lives. Ron Jeffries described the three Cs: card, conversation, confirmation. The card is a placeholder for a conversation that has not yet happened.

Velocity was designed to answer one question: given what this team has delivered in recent sprints, how much should we expect it to deliver in the next one? It is a forecasting input, calibrated to a specific team’s specific definition of a story point. It is not a measure of productivity, engineering quality, team health, or business value delivered. Using it as any of those things produces outcomes that are reliably bad.

Velocity was always a flawed proxy for progress. Teams learned to game it, inflate it, and defend it in ways that had little to do with delivering value. AI-assisted development has not fixed the underlying problem — it has made it worse, and in doing so forced a more honest conversation about what sprint planning is actually for. When individual developer throughput increases significantly — and for many teams working with AI coding tools, the increase in raw output is real — the assumptions baked into story point estimation break down.