Definitely, Maybe Agile

Organizational honesty starts with information: can your team actually see what's happening, and can they say it without fear of pushback?

Dave and Peter dig into why teams shade the truth when a deadline is on the line, and what actually creates room for honesty instead. They talk about the difference between activity data and real information, why cheap, near real-time visual management beats a hand-curated status report, and why the structure of a status meeting decides whether bad news gets absorbed or gets shot down. They also get into why understanding how work flows end to end matters more than staring at a single date on a calendar.

This week's takeaways:

• Cheap, near real-time visual management pulled straight from your work management systems gives people something honest to talk about instead of a filtered report.
• Structure in status conversations matters because it lets people absorb bad news and adjust instead of reacting defensively, which makes it safer to bring problems forward next time.
• Understanding how work actually flows end to end, not just watching a deadline date, is what shows you where the real bottlenecks and constraints are.

Listen to the full episode at definitelymaybeagile.com
 Subscribe so you never miss an episode.

 Have a question or topic you'd like us to cover? Reach out at [email protected]

AI is making it faster and cheaper to ship features. That doesn't mean you should ship more of them at once.

Peter and Dave dig into a pattern they're both starting to see: organizations using AI-assisted development as a reason to bring back big upfront planning and large project releases. The logic makes a certain kind of sense. If AI can build faster, why not design bigger? But that reasoning skips the part that actually mattered when teams moved to product delivery in the first place: validating that you're building what customers actually need.

The conversation covers why large releases make it harder to learn what's working, why feature parity with competitors is a trap, and what "North Star context" actually means when you're coordinating AI agents. The core argument: the planning layer is back in vogue for good reason, but the delivery layer still needs to be small and iterative. Cheaper to build doesn't reduce business risk. It just makes it easier to build the wrong thing faster.

This week's takeaways:

• AI augmentation speeds up building and releasing features, but it doesn't replace the need to validate whether those features are what customers actually want.
• A big picture plan is useful as context for AI agents and delivery teams, but over-specifying every step upfront wastes time on details that will change anyway.
• The goal isn't projects vs. product delivery. It's combining a clear long-term direction with small, measurable, iterative delivery tied to real outcome metrics.

Listen to the full episode at definitelymaybeagile.com
 Subscribe so you never miss an episode.
 Have a question or topic you'd like us to cover? Reach out at [email protected]

Tommy Cotter is Director of Data Products at Benzinga, a financial media company building the data infrastructure that sits behind trading platforms and investment apps used by millions of people daily. He's been navigating the shift to AI-assisted workflows in a space where speed and accuracy aren't just nice to have - getting it wrong has real consequences.

In this episode, Peter and Dave talk with Tommy about what it actually looks like to build data products responsibly in a fast-moving AI environment. They get into where humans still need to be in the loop, how compliance has become a competitive signal, and why being nimble matters more than picking the perfect architecture from day one.

Three things to take away from this conversation:

1. Self-agency is real now. If you have a strong conviction about a product or problem, the barrier to building something has never been lower. That's a genuine shift from even five years ago.
2. Security and compliance are no longer just internal concerns. In a world where AI startups spin up overnight, having invested in SOC2 or GDPR signals to customers that you're a legitimate, trustworthy operation. It's a market differentiator.
3. Humans still belong in the system. Not everywhere, but in the right places. For low-risk, deterministic processes, let AI run. For anything client-facing or accuracy-critical, keep a human in the loop. Knowing the difference is the skill.

If this conversation sparked something for you, send us your thoughts at [email protected]. And if you haven't already, hit subscribe so you don't miss the next one.

Royce Sin spent a decade at HSBC automating things nobody asked him to automate. He didn't ask for permission. He just did it, showed people the results, and let the time savings speak for itself. That instinct, to question why things are done a certain way and then actually do something about it, is what eventually led him into the AI space.

In this episode, Peter and Dave sit down with Royce Sin to talk about what it actually takes for AI to stick inside an organization. Spoiler: it's not about the tools.

We get into the tension between flexibility and reliability, why most people are being set up to fail with AI, and what it means to think like a manager when you're not one. Royce also shares his MIND framework, a practical way to think about AI adoption that he developed through hands-on work across enterprise and startup environments.

There's also a good conversation about the trades, no-UI as an ideal, and why the most dangerous move in transformation is knocking down fences you don't fully understand.

This week's takeaways:

• Think of AI as a new type of employee. Set it up for success the same way you'd set up your staff. Design roles and processes to match what it's actually good at.
• Not every rule is a hard rule. Before treating a constraint as a blocker, understand what's behind it. Some fences are load-bearing. Some aren't. Know the difference before you act.
• Don't just bring in AI. Know what outcome you're after. If you can't tell whether it's working, you don't have a tool problem, you have a clarity problem.

Have a thought on any of this? Reach us at [email protected]

As AI handles more of the foundational work, entry-level engineering roles are disappearing. Peter Maddison and Dave Sharrock examine why that trend is short-sighted, what junior developers actually contribute to team growth and AI adoption, and how organizations that skip early-career hiring may be trading long-term capability for short-term convenience.

This week's takeaways:

• Labeling the next generation as lazy or unprepared is as old as recorded history. Don't let that bias drive hiring decisions.
• Junior engineers accelerate AI adoption on the teams around them, not just in their own output.
• The questions a new hire asks in their first few weeks are often the most valuable ones your team will hear all year.

Subscribe to Definitely Maybe Agile for weekly conversations on Agile, DevOps, and the messy realities of organizational change. And if this episode resonated, send it to a leader who's thinking about cutting their graduate intake.

Conference season is back, and so are the real conversations. In this episode, Peter Maddison and Dave Sharrock catch up after a busy stretch of travel and dig into something Dave has been road-testing at conferences: why most people given access to AI tools freeze up, and what actually helps them move past that.

Dave ran a workshop at the Global Scrum Gathering in Vancouver for non-technical roles - product managers, Scrum Masters, agile coaches - people who've been told "use AI" but have no clear picture of where to start. What he found is that the problem isn't motivation or technical ability. It's the lack of scaffolding. Give people the right structure and the right room to experiment, and things shift pretty quickly.

The conversation then moves into multi-agent systems - how Dave's team built a group of agents that continuously refresh the workshop itself based on current thinking. Peter adds his own take on testing these systems with personas and automated quality evaluation. It gets a bit technical, but in the best way.

This is a good episode if you're thinking about how to help your organization actually use AI, not just adopt it on paper.

Key Takeaways:

• Context beats generic. Prompts work when they're specific to your role and your actual problems. A product manager needs product management context, not a one-size-fits-all example.
• Think in teams, not steps. Multi-agent systems work best when you treat them like a team reviewing an artifact, each agent checking for something different, rather than a linear build process.
• Don't assume everyone gets it. The gap between people who use AI daily and people who tried it once and gave up is wider than most of us realize. Getting both groups in the same room is where the real learning happens, for everyone.

Have a question or something to add? Reach out at [email protected] or find us at definitelymaybeagile.com. And if you're finding the show useful, subscribing and leaving a review goes a long way.

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 [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:

• 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 [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:

• 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 [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:

1. 100% utilization is not a goal. It's a warning sign. 
2. The right question isn't "how much capacity do we have?" It's "how much work in progress can we actually sustain?
3. AI accelerates your breaking points.

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.