In this episode of Building Better Developers with AI, Rob Broadhead and Michael Meloche revisit their earlier discussion on defining ‘done’ in Agile – how to stay on Track and Avoid Scope Creep. They explain why “done” must mean more than “I finished coding,” and they show how a shared Definition of Done (DoD) keeps teams aligned and projects on schedule.

What Does “Done” Really Mean?

In Agile, “Done” extends beyond writing code. It often includes:

  • Passing unit and integration tests
  • Receiving QA approval
  • Deploying to staging or production
  • Updating documentation
  • Securing acceptance sign-off

Without a clear, documented DoD, each team member may interpret “done” differently. As a result, projects risk rework, delays, and frustration.

“If we ask, ‘Is it done?’ we should get a clear yes or no—no ‘sort of’ or ‘almost.’” – Rob Broadhead

Why Ambiguity Leads to Trouble

Michael points out a common problem: a developer finishes their code, marks the ticket as done, and passes it to QA—only for testers to find gaps in the requirements.

A login screen ticket might say “Allow users to log in with username and password.” But does that mean:

  • Username is case-insensitive?
  • Special characters are allowed?
  • Do error messages display on failure?

If these details aren’t defined, both the developer and tester may interpret “done” differently, leading to frustration on all sides.

The Link Between “Done” and Scope Creep

Rob and Michael agree: unclear definitions open the door to scope creep. Without a firm DoD, features get stuck in an endless loop of revisions:

  • Developers feel QA keeps moving the goalposts.
  • QA feels developers aren’t meeting the requirements.
  • Clients think the delivered feature isn’t what they expected.

Over time, this erodes trust and pushes delivery dates further into the future.

Lessons from the Field

Michael contrasts two scenarios from his career that highlight the power of a strong Definition of Done.

Before an acquisition, his team worked with a crystal-clear DoD. Every ticket had precise requirements, clear acceptance criteria, and well-defined testing steps. As a result, tasks finished on time, testing followed a predictable pattern, and rework was rare. The team knew exactly when work met the agreed standards, and stakeholders trusted that “done” truly meant done.

After the acquisition, the situation changed dramatically. Tickets became vague and massive in scope, often resembling open-ended “make it work” directives. Multiple teams modified the same code simultaneously, resulting in merge conflicts, inconsistent results, and unpredictable delivery schedules. Without a clear DoD, developers, testers, and stakeholders all had different ideas of what completion looked like, and work frequently circled back for revisions.

The difference between the two environments came down to one factor: a clear and enforceable Definition of done. In the first scenario, it acted as a shared contract for quality and completion. In the second, the lack of it created confusion, wasted effort, and missed deadlines.

Building a Strong Definition of Done

The hosts outline key components every DoD should include:

  • Code complete and reviewed – Ensures quality and shared understanding.
  • Automated tests passing – Reduces regressions.
  • Documentation updated – Prevents future confusion.
  • Deployment verified – Proves it works in the target environment.
  • Acceptance criteria signed off – Confirms alignment with the original requirements.

Pro Tip: Keep your tests fresh—don’t just update them to pass without meeting the real requirement.

Who Owns the DoD?

One person doesn’t own the DoD—it’s a team responsibility. Product owners, Scrum Masters, and developers should collaborate to create and update it, reviewing it regularly to adapt to evolving project needs.

Making “Done” Part of the Process

Once defined, your DoD should be visible and integrated into your workflow:

  • Add it to user stories during sprint planning.
  • Track it in tools like Jira, Trello, or GitHub.
  • Use workflow stages that match your DoD steps—coding, testing, review, deployment, and sign-off.

Michael emphasizes that personal accountability matters just as much as team accountability. Great developers hold themselves to the DoD without needing reminders.

Your Challenge: Define “Done” This Week

If your team doesn’t have a documented Definition of Done—or if it’s been more than three months since you reviewed it—set aside time this week to:

  1. Write down your current DoD.
  2. Identify where ambiguity still exists.
  3. Get agreement from the entire team.
  4. Update your workflow so that every ticket must meet the DoD before it is closed.

This single step can prevent months of wasted effort and ensure your work delivers exactly what’s intended.

The Bigger Picture

A well-defined DoD is more than a checklist—it’s your guardrail against wasted effort and shifting goals. It ensures the final product matches what the client truly needs, not just what was coded.

Your Definition of Done is your “why” for each task—it keeps your work focused, aligned, and valuable.

Stay Connected: Join the Developreneur Community

We invite you to join our community and share your coding journey with us. Whether you’re a seasoned developer or just starting, there’s always room to learn and grow together. Contact us at [email protected] with your questions, feedback, or suggestions for future episodes. Together, let’s continue exploring the exciting world of software development.

Additional Resources

Leave a Reply