app-entwickeln-lassen.de LogoApp entwickeln lassen

Agentic Coding

Agentic Coding in Scrum and Kanban: How to Integrate It

app-entwickeln-lassen.de editorial team 6 min read
Contents
  1. What coding agents change in the agile process
  2. Backlog and refinement: writing agent-ready tickets
  3. Estimation and sprint planning
  4. Kanban: redesigning the flow
  5. Adapting the definition of done and Scrum events
  6. Getting started in five steps
  7. Conclusion
  8. Frequently Asked Questions

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:

  1. Goal and benefit in one or two sentences
  2. Acceptance criteria, ideally as testable statements
  3. Affected areas of the code, as far as known
  4. Boundaries: what must explicitly not change
  5. 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 elementAdjustment for agentic coding
"Ready" columnOnly tickets with complete acceptance criteria; optional "agent-ready" label
"In progress" columnSplitting into "agent working" and "human reviewing/steering" makes waiting time visible
"Review" columnKeep the WIP limit deliberately low so unreviewed changes do not pile up
WIP limits per personBackground agents count too – otherwise everyone starts too many parallel tasks
MetricsLead 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

  1. Define one sprint or a two-week period as a pilot
  2. Extend the ticket template with acceptance criteria and boundaries
  3. Update the definition of done and set a review WIP limit
  4. Make agent work visible in the daily and on the board
  5. 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 minutes

Conclusion

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.

This article was written by the editorial team of app-entwickeln-lassen.de – the app and AI development service of jocapps GmbH, based in Freiburg, Germany, and building apps since 2014. The content is for general information and does not replace individual (legal) advice.

You might also like

Agentic CodingCode Review for Agent-Generated Code: The Checklist

Code review for agent-generated code: a practical checklist covering requirements, architecture, tests, security and dependencies – for faster, safer reviews.

5 min read
Agentic CodingAgentic Coding for Startups: Reaching Your MVP Fast with a Small Team

Agentic coding for startups: how small teams use coding agents to reach an MVP faster, which pitfalls to avoid and when hiring an agency is the smarter route.

6 min read
Agentic CodingAgentic Coding Use Cases: 20 Tasks Agents Handle Reliably Today

Agentic coding use cases: 20 concrete tasks, from tests to refactoring and docs, that coding agents handle reliably today – plus limits and practical tips.

6 min read
Agentic CodingBuilding Custom Coding Agents: When Your Own Agents Pay Off

Custom coding agents or adapted standard tools? Criteria, architecture, effort and risks of building your own agents – so you can make the right call.

6 min read
Agentic CodingFrom Vibe Coding to Agentic Engineering: Professionalising Your Team

From vibe coding to agentic engineering: how dev teams use AI agents professionally with specs, tests and reviews – with a maturity model and practical steps.

6 min read
Agentic CodingAgentic Coding and Accessibility: Automating Accessibility Checks

Agentic coding and accessibility: how coding agents find and fix accessibility issues in web and mobile apps – and where manual testing remains indispensable.

6 min read