
Sign up to save your podcasts
Or


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:
Want to keep the conversation going? Drop us a line at [email protected] 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:
If this landed, share it with someone navigating the same tension. And reach out at [email protected] - 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:
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 [email protected].
Most organizations think they have a capacity problem. They usually don't.
What they have is a work-in-progress problem. And those two things call for very different solutions.
In this episode, Peter Maddison and Dave Sharrock dig into one of the most persistent headaches in organizational management: capacity tracking. Why does the instinct to measure utilization backfire? Why does loading people up to 100% actually slow things down? And what should leaders be asking instead?
The conversation covers the real cost of context switching, why that "nearly done" project is probably further away than it looks, and how AI is making all of this more urgent, not easier.
Three things to take away from this episode:
If this conversation resonated, there's more where it came from. Peter Maddison and Dave Sharrock explore these kinds of organizational challenges every week on Definitely Maybe Agile - the podcast that gets into the real complexity of modern ways of working, without the buzzwords.
Listen wherever you get your podcasts, or visit definitelymaybeagile.com to catch up on past episodes and reach out with your own questions.
AI is changing how products get built. That part isn't news. But it's also changing who needs to do what - and that's a conversation most organizations haven't had yet.
In this episode, Peter and Dave dig into one of the more interesting tensions emerging in 2026: as coding agents take on more of the actual development work, the thing that drives quality output isn't just better tooling. It's better context. Clear, structured, well-owned context that tells agents what you're actually trying to build, who it's for, and what can't be compromised.
Which raises a real question. Who owns that? Where does it live? And what happens when it's missing - which, let's be honest, it usually is?
They get into the rise of "context engineering" as a role, why the name creates its own problems, and what this shift means for product owners, product managers, and the long-standing gap between business and technology teams.
Key takeaways from this episode:
Want to continue the conversation?
If this episode brought up questions about how your teams are navigating the shift to agentic development - or where context ownership actually sits in your organization - reach out at [email protected]. We'd love to hear what you're seeing.
A lot of organizations are betting that AI will make their teams faster. Some of them are right. Most are solving the wrong problem.
AJ Bubb, founder of MxP Studio and host of Facing Disruption, joins Peter and Dave to talk about what actually happens when AI lands in a development team without fixing the system around it. If engineers can't get approvals, can't get access, and spend half their day in meetings, AI just means they produce more output the organization still can't handle. That's not a tooling problem. It's a structural one.
They also get into velocity without direction, what ownership really looks like when a ticket gets blocked, and why synthetic user testing might be the most polite way to avoid talking to actual customers.
This Week's Takeaways
If this episode got you thinking, we'd love to hear from you. Drop us a note at [email protected] or leave a review on your podcast app. And if you know someone navigating AI adoption right now, send this one their way.
Most organizations are running some version of a project operating model or a product operating model - or, more honestly, an uncomfortable mix of both. In this episode, Peter Maddison and Dave Sharrock get into what actually separates these two approaches, where the tensions show up, and why copying what works somewhere else rarely lands the way you expect.
They dig into how the nature of your work - ordered versus unordered, stable versus volatile - should shape how you plan, who holds decision rights, and how closely your experts need to stay involved. They also talk honestly about the hybrid trap: why trying to be all things to all teams usually ends up serving nobody, and what a smarter version of "borrowing from both" can actually look like.
Real examples from large organizations, including a couple of banks, show just how messy it gets when the model is mandated from the top without enough room for context.
Key takeaways from this episode:
Which end of the spectrum does your organization sit on right now - and is it actually working for you? Leave a comment below. We read everything.
Product manager. Product owner. Project manager. Three roles that often exist in the same organization, sometimes in the same meeting, and frequently stepping on each other's toes. In this episode, Dave and Peter break down what actually separates these roles, why the confusion happens, and what it costs when the lines blur in the wrong ways.
They dig into the difference between a project-centric operating model and a product operating model, and why that distinction matters more than most organizations realize. They also get into a concept Peter uses with clients: product owners reduce decision latency, project managers reduce reporting latency. It sounds simple, but the implications reach into how teams are funded, how authority is distributed, and why some transformations stall halfway.
The conversation covers real patterns from the field, including what happens when a technical project manager spends most of his time coordinating 14 dependency groups just so a product owner can get a decision made, and what it looks like when a project-centric funding model quietly undermines a product operating model that was never quite finished.
They also touch on where AI fits into all of this, and where it currently falls short as a bridge between these two worlds.
Three key takeaways from this episode:
If this is a conversation your team needs to have, share this episode with them. And if you're finding value in Definitely Maybe Agile, follow the show on your favorite podcast platform so you never miss an episode. New conversations drop every week.
Most organizations are somewhere between experimenting with AI agents and quietly hoping nothing breaks in production. Logan Kelly, CEO of Waxle AI, has spent a lot of time in that gap, and he thinks governance is the piece most teams are walking past too quickly.
In this episode, Logan joins Peter and Dave to talk about what agentic governance actually looks like in practice, why a single consistent layer beats a pile of point solutions, and how to keep developers moving fast without letting things go sideways when it counts.
This week's takeaways:
Most conversations about AI focus on what it can do in a controlled setting. This one doesn't. Callum Sharrock spends his days deploying AI systems in real environments, watching them succeed and fail in ways no simulation predicted, and reporting what he finds. His conclusion? The trend line is steeper than most people realize, and snapshot thinking is getting a lot of organizations into trouble.
Peter Maddison and Dave Sharrock dig into why reliability, not capability, is the real adoption bottleneck right now. They talk through what happens when non-deterministic models get applied to problems that need deterministic answers, why validation and testing are becoming more important than writing the code itself, and how the calculus around decision making is changing fast. If you can build and test something in the time it takes to debate whether to do it, the meeting starts to look like the problem.
They also get into what this means for developers, for leaders, and for anyone trying to figure out where to actually invest their energy right now. The barriers to building have never been lower. That makes the question of what to build more important than ever.
This isn't a conversation about AI hype. It's about what's actually happening at the frontier, and what it means for the way organizations make decisions.
This Week's Takeaways:
If this episode resonated, follow Definitely Maybe Agile wherever you listen to podcasts so you never miss a conversation. And if you know someone spending two hours debating whether to test an idea they could just build, send this one their way. There are plenty more episodes worth your time at definitelymaybeagile.com.