Community

translate Automatic translation · View original

New Practices for Agile Teams with AI

Canal Ia Para Agilistas

1 June 2026
New Practices for Agile Teams with AI
In a previous article we asked what to do with the practices we already have. This one asks something different: what new practices can emerge in a Scrum context with AI? The answer is more concrete than it seems. These are not theories: they are workflows, decision criteria, and reflection tools that real teams are testing right now, at different levels of maturity. None is definitive. All deserve to be known.

When a technology significantly changes the production process, the practices around that process need time to catch up. With generative AI that time has been compressed: in less than two years, concrete proposals have emerged across the three dimensions that structure agile work.

What follows is neither an exhaustive catalog nor a prescription. It is a map of what is happening, with the level of honesty that a terrain under construction deserves.

Technical practices: new workflows for new work


Test-Driven Generation (TDG)


Classic TDD follows a well-known cycle: write the test that fails, write the minimum code to make it pass, refactor. With AI, that cycle can be reorganized in a more powerful way. Chanwit Kaewkasi describes a variant in which the developer provides the requirements at a high level, the AI generates the tests based on those requirements, and then generates the code that must pass those tests. The developer reviews and validates.

The critical advantage over common practice is that when tests are generated from code that already exists, the model simply completes a token puzzle: it produces tests that match the code, not necessarily the correct behavior. TDG reverses that order and recovers the original principle of TDD: first define what the system must do, then build it. The DORA 2025 report confirms that this kind of foundational practice amplifies the positive impact of AI, acting as a safety net when the volume and speed of change skyrocket.

TDG is not a closed practice, but its logic is sound and replicable without needing special tools.

Context Engineering as a team practice


Prompt engineering had its moment in the spotlight in 2023 and 2024. In 2025 the best teams understood something more fundamental: the problem is not the prompt, it is the context. Andrej Karpathy and Tobi Lütke, CEO of Shopify, named this discipline "context engineering": the systematic management of what information the agent sees, when it sees it, and how it is structured.

The practical difference is significant. An agent that receives a generic prompt produces generic results. An agent that receives the right context—project architecture standards, existing code patterns, prior design decisions, specific technical constraints—produces outputs that are relevant and consistent with the real system. Some organizations are implementing a "context-oriented Definition of Done": no feature is considered complete until its technical documentation and architecture decision records are up to date. This ensures that the team's knowledge base—the organization's "long-term memory"—grows with every delivery.

As a team practice, context engineering has several concrete dimensions:

  • maintaining AGENTS.md files or equivalents with the project's conventions;
  • managing architecture decision records as the source of truth for agents;
  • and establishing who is responsible for keeping that context up to date.

Academic research on Structured Agentic Software Engineering puts it this way: an agent that can quickly integrate into the specific context of a team, project, or organization is more valuable than a brilliant but fragile agent outside its narrow domain.

Next-generation QA: AI supervising AI


Traditional testing assumes that humans write the tests to verify code written by humans. When both sides of that equation can involve AI, the QA model needs rethinking.

Three complementary approaches are emerging:

  • Using one AI as an automated reviewer of another's output: automated checks that detect patterns of technical debt, duplication, security vulnerabilities, or code that does not follow project standards, before that code reaches human review.
  • Specification by Example (SbE): creating tests based on concrete, verifiable examples that serve as a specification of expected behavior. This approach is considered especially relevant because AI cannot "grade its own homework": if it is asked to generate code and then review it, it will tend to validate what it produced itself.
  • Continuous auditing of code health metrics as an explicit counterweight to generation speed.

None of these approaches replaces human review. They complement it and make it more efficient, filtering out mechanical problems so that human attention can focus on logic and architecture errors that AI does not detect.

Management and flow practices: rethinking how work is organized


Three-level estimation


Story points were designed to estimate human cognitive effort in implementation work. When part of the work is executed by an agent, that unit of measure stops being homogeneous. We propose explicitly distinguishing three types of work:

  • Automated tasks (Zero-Point) are those that AI executes autonomously or nearly autonomously. They are not estimated in story points: they are measured by computational cost and the human review time required.
  • Human tasks (Standard) require creativity, judgment, or knowledge that AI cannot provide; they are estimated with the usual methods.
  • Review and integration tasks (R&I) are human work devoted to reviewing, validating, and integrating what AI generates. They are the easiest to underestimate and the ones that create the most bottlenecks. Estimating them explicitly is what prevents the scenario where all the code is "generated" but nobody has been able to review it.

The logic behind this model connects directly with what the research documents. DORA 2025 found that AI tends to significantly increase the size of PRs, creating a direct tension with the practice of working in small batches. The R&I estimate is the mechanism that makes that bottleneck visible before it reaches the end of the sprint.

Definition of Ready for AI


The classic Definition of Ready defines when a story is ready to enter a sprint: defined, estimated, with clear acceptance criteria. When part of the sprint work will be executed by an AI agent, that definition needs an extension.

A story is "ready for AI" when it also meets the following: the specification is detailed enough for the agent to generate relevant output; the agent has access to the necessary context (architecture, standards, project patterns); the acceptance criteria are verifiable and objectively testable; and the human review time for the output has been explicitly estimated and included in the planning. This last condition is the one most often omitted and the one that creates the most bottlenecks.

The A3 Framework: Assist, Automate, Avoid


Stefan Wolpers has documented a simple, actionable decision framework for teams that need explicit criteria on what they delegate to AI. The A3 distinguishes three categories:

  • work that AI should assist with (the human keeps judgment, AI speeds up execution);
  • work that AI can automate (routine execution with periodic review);
  • and work that is better not delegated to AI (ethical judgment, managing team conflicts, strategic product decisions).

The value of the A3 lies not in the categories themselves but in the fact that the team has an explicit conversation about where those boundaries sit in its specific context. Without that conversation, delegation happens by inertia.

Team practices and reflection: making what happens by default conscious


The AI governance retrospective


The standard retrospective examines how the team's process has worked: what went well, what to improve, what to experiment with. On teams using AI, there is an additional dimension that rarely enters that conversation in a structured way: how the integration of AI into the process is going.

The XP2025 workshop on AI and agile development identified as a central challenge that most agile teams lack clear guidelines on how to operationalize AI governance in daily work, including how to ensure compliance with data protection rules, how to manage intellectual property of AI-generated artifacts, and how to maintain transparency in AI-assisted decisions.

The AI governance retrospective is a periodic session (not necessarily every sprint; it can be monthly or quarterly) that specifically examines these questions:

  • What proportion of the code we deliver has been generated by AI, and who reviews it?
  • Does our DoD reflect how we actually work?
  • Have the team's roles changed in practice, and have we made that explicit?
  • Are there decisions we are delegating to AI that should be human?
  • Do we have clear criteria on which project data AI may process and which it may not?

It is not a compliance audit. It carries the same spirit as the classic retrospective (making what happens visible, deciding what to adjust), applied to a territory that teams are navigating without a map.

The AI integration canvas


Beyond the retrospective, some teams are using structured reflection tools before adopting AI into new workflows, not just afterward. A simple canvas with five dimensions can serve as a starting point for that conversation:

  • What is AI doing in our current workflow (even informally and without agreement)?
  • What friction are we feeling in that integration?
  • What criteria do we have for deciding what we delegate and what we don't?
  • How do we review AI output before considering it valid?
  • How will we learn whether this is working or not?

The AI4Agile Practitioners Report 2026 describes what practitioners ask for when asked what they would improve: not more powerful models, but tools that fit into their sprint without friction, with outputs that understand their team's specific context and domain. The canvas is not an AI tool; it is a team conversation. But it is precisely the kind of practice that allows that integration to be deliberate rather than reactive.

A note of honesty about the state of the art


Most of the practices described here have between six months and two years of documented history. Some have names and clear references; others are patterns that different teams are discovering independently without having named them yet. None has the accumulated empirical backing that TDD, planning poker, or the retrospective have.

That does not make them any less valuable. The agile community has always worked this way: retrospectives were not in the original Scrum, nor was backlog refinement. They emerged because real teams found they needed them. The same is happening now, with the difference that the pace of emergence is faster than ever.

The practices described in this article are not magic solutions. They are tools for making AI integration conscious, reviewable, and improvable. Which is exactly what agility has been proposing for decades for everything else.

Are you using any of these practices, or something similar? Have you invented something in your team that isn't here?

Bibliography


  • Ashmore, D. (2026). 5 ways agentic engineering transforms agile practices. CIO.
  • Dell'Acqua, F. et al. (2025). The Cybernetic Teammate. Harvard Business School Working Paper No. 25-043.
  • Google Cloud / DORA (2025). State of AI-Assisted Software Development.
  • Hassan, A. et al. (2025). Agentic Software Engineering: Foundational Pillars and a Research Roadmap. arXiv.
  • Kaewkasi, C. (2025). Test-Driven Generation (TDG): Adopting TDD Again This Time with Gen AI. Medium.
  • Karpathy, A. & Lütke, T. (2025). Context Engineering.
  • Seidel, F. et al. (2025). AI and Agile Software Development: A Research Roadmap from the XP2025 Workshop. arXiv.
  • Wolpers, S.
    • (2025). A3 Framework: Assist, Automate, Avoid. Age-of-Product.com
    • (2026). AI4Agile Practitioners Report 2026. Age-of-Product / Scrum.org.

Take part in the poll

This article includes an active poll in the Scrum Manager community.

poll View the poll in the community