• AI Can Copy Your Product but Not Your Customers
    Nov 19 2026

    When AI can build and copy software in days, what is your startup moat? Peter and Dave argue the protection that lasts comes from customer value, not from shipping features first.

    Getting a product to market used to protect a well-thought-out idea. Now development is basically a utility. An incumbent with funds and technical skill can point an agent at your product and copy it the week you launch. Peter Maddison and Dave Sharrock talk through what still holds up. Traditional moat tools like Porter’s Five Forces and network effects were built for global players like Uber, and they do little for a small startup. The protection that still works is knowing your customers’ pain points well enough to fit a narrow niche better than anyone else, then running the experiments that prove it. They also find a moat nobody expected: the internal processes that made your company successful can now become custom tools that only you have.

    This week’s takeaways:

    • A copied product does not win customers by itself, because people stay with tools that work well enough unless they have a real reason to switch.
    • Product market fit has gone from a nice idea teams nod along to into a must-have, since understanding the customer’s problem is one of the few advantages that is hard to copy.
    • Small and medium companies can turn their own back-office processes into automated tools built for a market of one, and competitors cannot buy that off the shelf.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    20 mins
  • AI Meets The Software Delivery Bottleneck
    Nov 5 2026

    AI can push software delivery to machine speed, but your customers, approvals and decisions still move at human speed. That gap decides what AI really changes.

    Peter Maddison and Dave Sharrock look at the AI software delivery lifecycle through clock speed. Code generation is getting close to machine speed. Customer behavior, product discovery and the approvals needed before anything gets built still run at social speed. They come back to the theory of constraints: the whole system moves at the pace of its slowest part, and coding has rarely been that part. Along the way they talk about what it means to build a hundred variations of a feature, why token and validation costs add up fast, and why moats shrink when competitors can copy a product in weeks.

    This week’s takeaways:

    • Speeding up code generation does little for delivery when the real constraint sits in discovery, approvals and waiting to see how customers respond.
    • Building many versions of an idea is now cheap, but every thrown-away version costs tokens, and validating what customers actually want is still slow.
    • Social speed is part of your moat, so be careful about replacing human interactions with machine ones in places where customers value the human part.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    20 mins
  • AI in the SDLC Is Only as Good as Its Context
    Oct 29 2026

    AI in the software delivery lifecycle is moving faster than any process you can write down. A model that works today may be wrong in a month or two.

    Dave Sharrock and Peter Maddison unpack what AI is really doing to the SDLC, from ideation and design through build, release, and operations. They start with Anthropic’s recent paper on an AI-native SDLC. Peter has spoken with its authors and sees useful ideas in it: capturing intent, using agents to build several versions and pick the best, and handing operations over to agents. He also sees gaps around where context lives, how it is versioned, and what happens when it goes stale. Dave compares two paths he sees in organizations. Some run AI-native delivery alongside their existing systems. Others swap AI into parts of the process they already have. In both cases, context, governance, and architecture matter more than they did before.

    This week’s takeaways:

    • Treat published AI-native SDLC models as sketches, not blueprints, because they leave real gaps, especially for large and regulated organizations.
    • Agents still need to know the purpose and constraints of what they are building, or they will happily layer in abstraction until the system is far more complex than it needs to be.
    • Govern two things: whether the system produces the right output, and whether your agentic orchestration still behaves correctly every time the underlying models change.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    21 mins
  • Outcomes Over Output with Mik Kersten
    Oct 22 2026

    AI can now produce output faster than most organizations can absorb it. Mik Kersten explains why the move from output to outcome has become a leadership job.

    Mik, author of Project to Product and his new book Output to Outcome, joins Peter and Dave to talk about what happens when coding stops being the bottleneck. For years, business teams fought to get their feature into the next plan because delivery capacity was scarce. With agents taking that constraint away, the bottleneck moves. It might be customer adoption, security reviews, budget, or how long it takes to get real feedback. Mik walks through the outcome loop, which connects strategy and budget to outputs and then to customer and business outcomes, and explains how to apply the theory of constraints to it. He also covers the outcome tree, a way of cascading company-level targets down to the value streams doing the work. Peter and Dave push on the hard parts: business leaders who can’t name their top outcome, B2B teams that wait months for usable feedback, and operating models that fall apart once the leader who championed them moves on.

    This week’s takeaways:

    • When AI removes coding as the constraint, the bottleneck shows up somewhere else, so measure the whole loop from budget to customer outcome and go find it.
    • If a team can’t connect its work to a company-level outcome, the strategy was never decomposed, and moving faster only makes that gap more obvious.
    • Outcome ownership needs to sit with the teams closest to the work, with the business at the table, and the operating model has to outlast any single leader.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    36 mins
  • Is Spec-Driven Development Just Big Upfront Design?
    Oct 8 2026

    Spec-driven development with AI is getting a lot of attention. Peter and Dave ask when that structure actually helps you, and when it slows you down.

    They start with the AI SDLC white paper Anthropic recently published. It lays out a structured, spec-driven approach built for consistency. Peter sees it working best on large legacy systems, the kind with millions of lines of code written over 15 years by thousands of people. For greenfield work, a looser approach of prototyping and exploring often fits better. Dave pushes on the piece most teams drop: the feedback loop. Everyone agrees to review and validate, and then the next shiny feature shows up. They also cover what happens when an AI agent follows an over-detailed spec too literally, why systems thinking beats chasing every edge case, and how explore versus exploit plays out differently for a startup and a company with 10 million customers.

    This week’s takeaways:

    • A structured, spec-driven SDLC pays off on large, complex systems where stability matters, but it can feel like far too much when you are just prototyping something new.
    • Define enough up front to guide the work, then rely on regular check-ins and feedback loops to course-correct, because no spec can predict every case and an AI agent will happily take the shortcut you never meant to allow.
    • Explore and exploit are not either/or. Organizations can now run both under one roof, as long as they know where they sit on the path from startup to established player and use judgment about how much structure to add.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    20 mins
  • How to Validate AI Output Before You Trust It
    Oct 1 2026

    AI agents will tell you everything works. Here is how to validate AI output when the mistakes are ones no human would ever make.

    Peter and Dave compare notes from building software, training material, and presentations with AI. The problems they keep running into are strange ones: the wrong database ID dropped into a system, 236 passing tests that test nothing, and five layers of abstraction added to a solution that needed none of them. Their answer borrows from good agile practice. Define what validation means before the agent starts, the same way a team agrees on its definition of done. Keep checking that the context you gave the AI is still relevant as the work moves. And keep someone in the loop who knows the problem well enough to look at the result and say, "Actually, you got this wrong."

    This week's takeaways:
    - Decide what "done" and "valid" mean before you hand work to an AI agent, and use a separate agent to grade what comes back.
    - A test suite that pings components or mocks everything out can report hundreds of passes and prove nothing, so ask for synthetic transactions that run through the whole system.
    - AI will happily over-engineer a small problem, so someone needs enough knowledge to ask whether the solution fits the size and scale of what you are actually trying to solve.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    15 mins
  • Why AI Agents Don't Belong on Your Org Chart
    Sep 24 2026

    Giving AI agents names and a spot on the org chart makes people feel less accountable for the work, and it squeezes the agent into a role it doesn't need.

    Dave Sharrock and Peter Maddison dig into new research from the September/October 2026 issue of Harvard Business Review on what happens when organizations add named AI agents to the org chart. When people use AI as a tool, they own the result and check it carefully. When the same work comes from a personified agent, accountability quietly shifts to the software, and nobody is really holding it. Peter connects this to the idea of accountability sinks, the layers in an organization where responsibility disappears. They also talk about review fatigue, the growing pile of AI-generated documents, slides, and code that someone still has to read, understand, and sign off on. Onboarding an agent like a new hire still makes sense. Leaving it on the org chart with a name is where the trouble starts.

    This week's takeaways:
    - How people work alongside capable AI agents is still poorly understood, and the old problems of ownership, accountability, and decision making do not go away just because an agent is involved.
    - Review fatigue is real and getting worse, because cheap generation still means expensive human review for every artifact someone has to approve.
    - Naming an agent into a human role limits it to the shape of that role, while treating it as a tool in the workflow lets it work across boundaries in ways a person cannot.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    19 mins
  • AI Changes The Real Bottleneck with Bernie Maloney
    Sep 17 2026

    AI speeds up building. It doesn't speed up deciding. The real bottleneck has moved to management, and organizations don't see it yet.

    In this episode, Peter and Dave talk with Bernie Maloney about why AI adoption is exposing a critical gap in organizational leadership. AI is accelerating delivery and implementation. But the pressure for deciding what's worth building has moved upstream faster than most companies can adapt. That means managers can't just be administrators anymore. They need to understand the work hands-on (the "player" part) while coaching teams to see the bigger strategic picture.

    Bernie walks through a three-dimensional view of Agile: output (how to build), outcome (how to solve problems), and impact (what problems are worth solving). Most organizations only operate in one. He also explains why the discovery plane—figuring out what to build in the first place—has to move closer to teams instead of staying locked at the management layer. That's where the real bottleneck lives now, not in engineering.

    This week's takeaways:

    • Agile moved the bottleneck from production to deployment. AI is moving it again, this time to deciding what's worth building in the first place.
    • Managers need to become player coaches: staying close to the actual work so they understand what's possible, while coaching people to think strategically about the system they operate in.
    • Psychological safety and tolerance for intelligent failure have to come before speed. Without them, faster delivery just means faster mistakes.

    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 feedback@definitelymaybeagile.com

    Show More Show Less
    38 mins