Most organizations think they're doing AI. They've bought the licenses, rolled out the tools, and told the team to start using Copilot. But adding AI on top of a 40-year-old process isn't transformation. It's decoration.

Andre Kaminski, Director of Advanced Technology Solutions at WorkSafeBC and author of "The AI-Native Software Development Lifecycle," joins Peter and Dave to talk about what it actually means to rebuild your delivery process around AI, not just bolt it on.

They get into why optimizing code generation alone is the wrong focus, what the six phases of an AI-native SDLC look like in practice, and why the biggest challenge isn't the technology at all. It's the identity shift that comes with it.
If your organization is asking "which AI tool should we use?" this episode will help you realize that's probably the wrong question.

In this episode:

• Why AI-augmented and AI-native are very different things
• The compounding learning effect and why early adopters are pulling further ahead every month
• What prompt architecture actually means and why it matters more than code
• How to think about governance when prompts become your new source of truth

Want to keep the conversation going? Drop us a line at feedback@definitelymaybeagile.com or find us at definitelymaybeagile.com. If this episode got you thinking, share it with someone who needs to hear it.

Agreeing on an idea doesn't mean you both understood the same thing. Dave Sharrock and Peter Maddison dig into why shared context breaks down in practice, and how AI makes that problem harder to ignore.

This week's takeaways:

• Intent is always imperfect. Define how you'll validate it, not just what it is.
• Ambiguity in context isn't a bug. It's necessary. Validation is how you confirm you're aligned.
• Drive down the cost of validation, not just the cost of building.

If this landed, share it with someone navigating the same tension. And reach out at feedback@definitelymaybeagile.com - we read everything.

It doesn't happen all at once. A great idea comes out of a strategy session. Someone turns it into a PowerPoint. Another person summarizes that PowerPoint with AI. By the time it reaches the team building it, the sharp edges are gone and nobody quite remembers what made the idea worth pursuing in the first place.

Peter and Dave dig into a problem that's older than AI but getting harder to ignore. How does intent get lost as it travels through layers of people, tools, and artifacts? What does a shared context document do that a business case can't? And what can the architectural world teach the product world about keeping the thread from unraveling?

Key takeaways:

• Moving artifacts backwards and forwards through an organization strips out nuance at every step. A single central context document is a more honest way to carry intent from strategy to delivery.
• AI is being actively encouraged in most organizations right now, and in using it, teams may be quietly eroding the ideas behind what they're building without realizing it.
• If your outcomes don't match your original intent, the handoff chain is usually where things went wrong. That's worth looking at before blaming the team.

Try this: Trace one idea from your last strategy session all the way to what actually got built. See if you can find where it changed. Then come tell us what you found at feedback@definitelymaybeagile.com.