Contents
Agentic coding fits well into Scrum and Kanban, but it noticeably changes some habits: tickets need to be written more precisely, estimates shift, review becomes the bottleneck and the definition of done needs new criteria. This article shows which adjustments work in practice – event by event and artefact by artefact.
What coding agents change in the agile process
Agile frameworks describe how a team plans work, makes it visible and improves. Agents do not change that. They do change how work gets done inside a ticket – and that has knock-on effects:
- Implementation gets faster, clarification does not: when code is produced in a fraction of the time, the quality of requirements becomes the limiting factor.
- The bottleneck moves: instead of writing code, work piles up in review, testing and business clarification.
- Work becomes partly asynchronous: agents can handle tasks in the background while developers work on something else.
- The developer's role shifts towards specification, steering and verification.
If you are a client and want to understand the basics of Scrum first, we recommend our article agile app development: Scrum explained for clients.
Backlog and refinement: writing agent-ready tickets
A ticket that is enough for an experienced developer with project knowledge is often too vague for an agent. At the same time, humans benefit from more precise tickets too. An agent-ready ticket contains:
- Goal and benefit in one or two sentences
- Acceptance criteria, ideally as testable statements
- Affected areas of the code, as far as known
- Boundaries: what must explicitly not change
- References to designs, API documentation or comparable implementations in the code
During refinement it pays to decide together whether a ticket is "agent-ready" – that is, can mostly be implemented by an agent – or first needs technical clarification by a human. This label helps with planning later. Our article on how AI changes the product owner role describes how the PO's work shifts along the way.
Estimation and sprint planning
Story points measure complexity and uncertainty, not typing speed. That is why estimates drop less with agents than many expect. Realistically:
- Routine tasks with a clear pattern get much smaller – this is where the agent shines.
- Tasks with business uncertainty stay about the same, because clarification drives the effort.
- Review and testing effort should be estimated explicitly instead of staying implicit.
After introducing agents, expect velocity to fluctuate for a few sprints. Recalibrate rather than simply extrapolating old figures. For sprint planning: plan not only developer capacity but review capacity. A team that produces twice as many pull requests but cannot review more will not get faster.
Kanban: redesigning the flow
In Kanban teams, the shifting bottleneck is especially visible on the board. Proven adjustments:
| Board element | Adjustment for agentic coding |
|---|---|
| "Ready" column | Only tickets with complete acceptance criteria; optional "agent-ready" label |
| "In progress" column | Splitting into "agent working" and "human reviewing/steering" makes waiting time visible |
| "Review" column | Keep the WIP limit deliberately low so unreviewed changes do not pile up |
| WIP limits per person | Background agents count too – otherwise everyone starts too many parallel tasks |
| Metrics | Lead time, waiting time in review, share of rejected agent changes |
Especially when agents work asynchronously, it is tempting to kick off many tasks at once. More on this in background agents and asynchronous tasks.
Adapting the definition of done and Scrum events
Extending the definition of done
The definition of done is the most important lever for securing quality in agent-generated code. Add items such as:
- The change has been fully read and understood by the person who instructed the agent
- A second person has reviewed it
- Automated tests cover the acceptance criteria and run in the pipeline
- No new dependencies without a conscious decision
- The agent's context files have been updated if new conventions emerged
Daily, review and retrospective
Daily: alongside "What am I working on?", the question "What are my agents running, and where do I need review?" becomes relevant. Blockers arise more often from missing reviews or unclear requirements than from technical problems.
Sprint review: little changes for stakeholders – they see working software. Transparency about agent use builds trust, though, for instance when a team shows how quickly a feature request could be implemented.
Retrospective: this is where the biggest learning potential lies. Useful questions: which tickets did the agent solve well, which not? Where did we need a lot of rework? Which rules belong in the context files? Metrics as described in our article on agentic coding metrics help as well.
Getting started in five steps
- Define one sprint or a two-week period as a pilot
- Extend the ticket template with acceptance criteria and boundaries
- Update the definition of done and set a review WIP limit
- Make agent work visible in the daily and on the board
- Evaluate the experience in the retrospective and adjust the rules
Many teams use joint training for this start. Our agentic coding workshops start from 799 € net; we place AI developers from real-world practice as trainers and agree content and format – such as integration into your existing Scrum or Kanban process – individually.
Planning an app? Request a free fixed-price quote in 2 minutesConclusion
Scrum and Kanban remain the right frameworks with coding agents. What matters is taking the shifted bottlenecks seriously: more precise tickets, explicitly planned review capacity, low WIP limits in review and an extended definition of done. Teams that make these adjustments deliberately benefit from the speed of agents without losing quality or overview.
Frequently Asked Questions
Does agentic coding require a fundamental change to our Scrum process?
No. Roles, events and artefacts stay the same. The main adjustments concern ticket quality, estimation, review capacity and the definition of done.
How do you estimate tickets that an agent implements?
Keep estimating complexity and uncertainty, but explicitly include review and testing effort. After a few sprints, recalibrate your reference values.
Is Kanban or Scrum a better fit for agentic coding?
Both work. Kanban makes bottlenecks such as review particularly visible, while Scrum's retrospective provides a fixed slot to improve agent rules regularly.
Who in the team is responsible for the agent?
The person who picks up a ticket and uses an agent for it is responsible for the result. The team as a whole maintains shared rules and context files.