
Nothing on this list is new, and that's the point. Every item is something agile coaches and Scrum Masters have been saying for twenty years. What AI changed is the price of ignoring them. A team that skipped the basics used to find out in a quarter, and now it finds out within days, with a lot more code to unwind.
So I don't think surviving this shift means learning a whole new playbook. I think it means repeating the old one, more clearly and more often, to people who are moving faster than ever and are very tempted to believe the old rules don't apply to them anymore. Here are the ten I find myself repeating the most.
1. Faster isn't better unless the whole flow gets faster
Years ago Mik Kersten shared a number from Nationwide that I've never forgotten. When they mapped their end-to-end value stream, only about 2.5% of the time was spent in development. The other 97.5% went to everything around it: waiting, deciding, approving, handing off, testing and releasing.
Now ask yourself what happens to that organization if AI makes the 2.5% twice as fast and nothing else changes. Almost nothing reaches the customer sooner. What you get instead is a much bigger pile of finished code waiting in line behind the same old bottlenecks. A National Bureau of Economic Research study of more than 500,000 GitHub developers found exactly that shape. Among developers using autonomous coding agents, commits went up about 240%, while releases went up about 30%.
The bottleneck has always been deciding what to do, aligning it to strategy and getting it safely into production, and that's where a coach's attention belongs.
2. Build what's worth owning
When building gets cheap, the temptation is to build everything. The backlog starts to look like a plate at Thanksgiving dinner, and the team acts like the kid who was told to clean it before leaving the table. Except here, a clean plate doesn't earn dessert. You just end up with a big bloated belly.
Keep glancing over your shoulder at the top of the backlog while you work, because the thing waiting there may now matter more than the thing you're still finishing. When it does, have the discipline to stop and switch rather than cleaning your plate. Every feature you build has to be maintained, secured, understood and eventually changed, long after the AI that wrote it in an afternoon has moved on. Cheap to build is not the same as cheap to own, so the question is still what's worth building, not what's possible to build.
3. AI will fill the gaps, so tell it where the gaps are
You may have seen the viral videos where kids share instructions for making a peanut butter sandwich and a parent follows them exactly. "Put the peanut butter on the bread" ends with the jar plunked on top of the loaf, knife and all. That's my cover image, and it's the most accurate picture of working with AI I know, with one twist. A person following your instructions literally gets it obviously wrong. AI fills in what you left out with something reasonable-looking, confidently, and often never mentions that it guessed.
People fill gaps by asking. AI fills them by assuming, unless you tell it otherwise. So the old agile habits of a clear story, a conversation with the Product Owner and questions asked early all matter more now. Addy Osmani's "doubt-driven development" skill is a good example of writing that habit down: important decisions go to a reviewer that starts fresh and is told to try to disprove the work, not approve it. Make your AI show you its assumptions before it builds on them.
4. Green checks aren't a guarantee
Automated tests are wonderful, and AI makes them cheaper to write than ever. But a wall of passing tests only tells you the code does what the tests ask. It doesn't tell you the tests ask the right things, and an agent under pressure to get to green has been known to weaken a test or quietly delete one. You still need some smarts in the loop to make sure you aren't fooling yourself.
The best fresh eyes are still a tech-savvy human who didn't build the thing. If you can't get one, use AI started fresh: a new session with no memory of the build, given the work and what it's supposed to do, and asked to find what's wrong. That's Osmani's doubt-driven idea again. What doesn't work is asking the same AI that wrote the code whether the code is good.
5. Write the guardrails down
Teams that work well have working agreements. Teams working with AI need them even more, whether you call them working agreements, a constitution, or the instructions file in your repo. The single most useful habit to write down is don't assume, pause. In my experience the pause points that matter most are these:
Customer impact. Anything that touches a customer or changes what a customer sees.
Business rules. Any assumption about a definition, a business rule or a number. Those belong to the Product Owner.
Hard-to-undo changes. Anything hard to undo, like changing the database or something customers already rely on.
Conflicting sources. Any time the research turns up sources that disagree. Lay out the options and ask, rather than quietly picking one.
Pause at the moments that matter, though, not after every step. Approving every move soon becomes a reflex, and a reflex isn't a check.
6. Agree on done before you build
Acceptance criteria and a Definition of Done used to feel like paperwork to a lot of teams. With AI they've quietly become the spec, because they're the only description of success the AI gets to work from. The teams I see doing this well write the outcome right on the story, as in "we'll know this is working when…", and agree on it before a single line is generated. Then the tests show what was built, and the Product Owner confirms whether it actually reached the outcome. Passing tests don't get to skip that step.
7. The Product Owner has to say no
Most of us learned what a Product Owner really does by watching Pat in Henrik Kniberg's Agile Product Ownership in a Nutshell. A big part of Pat's job is saying no, so the team works on the things that matter most and the backlog doesn't grow without end. It has never been more true. When anything can be built in a day, the Product Owner's no, guided by the product vision and strategy, is the main filter left.
Say yes to everything and Kent Beck will tell you where it ends. In his writing on augmented coding, he describes AI adding extras nobody asked for, each one adding complexity that slows the next change, until progress stalls and the code turns brittle. If you aren't deliberate about what you build, and about architecture, security and the things that hold it all together, you can build a house of cards by accident, one small reasonable change at a time.
8. AI is not your user
People still don't talk to their customers enough, and AI is about to make that worse. It's so easy to ask, "Hey AI, do you think this is good?" and get back, "Oh yes, this is brilliant, I'm sure your users will love it!" Anthropic's own engineers found that AI asked to grade its own work tends to praise it even when the work is mediocre, and that's a fast road to false confidence that what you're building is right.
AI role-playing a customer can catch the most obvious problems early, and that's useful. But it's a rough first pass, not a substitute for real people. The time AI saves us is the time we finally have to do the parts of the job that matter: be a good human, go talk to customers, decide the right things to do, and double-check that everything we ship has quality and purpose.
9. Kanban makes sense, and it takes more discipline, not less
For teams where agents do much of the building, a continuous flow often fits better than a fixed sprint, and I think that's fine. But I keep hearing Kanban described as "Scrum with fewer rules," and it has never been that. Kanban asks you to make the work visible, limit work in progress, manage the flow, make your policies explicit and keep the feedback loops tight. The WIP limit is the hard part, and AI is going to make it harder every day.
When starting something new costs almost nothing, there's always a reason to start one more thing. AI will hand you endless excuses to just keep building. Staying small, keeping feedback tight and deliberately deciding what to do next take real discipline in a flow system, so if your team drops sprints, make sure it doesn't drop the discipline along with them.
10. Ask for the simplest thing that could possibly work
Ward Cunningham's old question, "What's the simplest thing that could possibly work?", might be the most useful sentence in agile right now. AI will happily give you the most complete thing, the most clever thing or the most everything. Asking for the simplest version, learning from it and then deciding what comes next is still how good products get built.
None of these ten is new, and that's exactly why they matter. AI hasn't repealed the basics of agile. It has raised the stakes on every one of them and shortened the time between ignoring them and paying for it. Our job as coaches and Scrum Masters is to keep saying the obvious things, out loud and often, until they stop being obvious and start being habits.
In Assembled. Aligned. Adaptive., these ten don't live in one chapter. The flow items sit with Kersten and Reinertsen in the flow part of the model, the Product Owner's no and the customer conversations belong to product thinking, and none of the guardrails last without leaders who back them. If the Nationwide number stuck with you, Chapter 8 picks it up and shows what to measure instead of velocity. You can start here.
Sources
Mik Kersten, "Project to Product: How Value Stream Networks Will Transform IT & Business," DevOps Enterprise Summit 2018 (IT Revolution transcript), on Nationwide's 2.5%.
Demirer, Musolff and Yang, "Writing Code vs. Shipping Code," NBER Working Paper 35275 (May 2026), on AI tools, commits and releases (500,000+ developers).
Addy Osmani, agent-skills, the "doubt-driven-development" skill.
Henrik Kniberg, Agile Product Ownership in a Nutshell (video).
Kent Beck, "Augmented Coding & Design: The Genie Eats the Seed Corn" (May 2025).
Anthropic, "Harness design for long-running application development" (March 2026), on AI praising its own work.