Chapter 4: Who does what and when
This introduction explains that teams should adapt BDD to their local development context rather than follow a fixed process.
After this chapter you will be able to
- Contextual BDD process design. Explain why a team should adapt its BDD process to its development method, organizational roles, and team members, then review and adjust that process as needed.
- Story preparation and discovery. Trace how a selected user story moves into discovery: stakeholders prepare the story and candidate rules before a workshop, then business, development, and test perspectives discuss rules and examples to refine them.
- Scenario formulation and business review. Explain how the team turns discovered examples into business-readable scenarios before implementation and has business representatives review them for correct behavior and terminology. Describe why scenario writers must make those scenarios worthwhile to review.
- Scenario-driven automation and implementation. Explain why the preferred order is to automate a scenario before implementing it, then write application code to make the failing scenario pass. Distinguish this from automating only after implementation.
- Scrum sprint workflow. Describe how Scrum prepares and selects user stories during a sprint, then reviews the results and discusses process improvements. State that BDD works well with Scrum without claiming that this section explains how to integrate them.
- Discovery Meetings in Scrum. Describe where BDD discovery fits in Scrum and how the team can schedule it according to access to the product owner.
- Examples Focus Discovery Discussions. Explain how discussing examples affects early requirements conversations and why scenario writing helped the team in the story finish sprint planning sooner.
- Formulation in the story pipeline. Explain why Scrum teams should formulate scenarios as the first task in a story’s implementation pipeline rather than during a requirements workshop.
- Small-group formulation and approval. Explain who typically formulates scenarios, how business review fits in, and why required approvals must be planned.
- AI-assisted human scenario review. Distinguish the preliminary checks AI can perform from the final human validation required before scenarios drive development.
- Scenario Aligned Task Planning. Distinguish development tasks from examples and scenarios, and explain how a team can use scenarios to plan tasks. Describe why a task should relate to one scenario where practical, while recognizing that some tasks support several scenarios.
- Visible Functional Progress. Explain why completed end-to-end scenarios provide earlier feedback, allow manual testing to start, and communicate progress better than technical task completion or a percentage.
- Kanban flow and discovery. Explain how Kanban’s work-in-progress limit affects when a team uses Example Mapping to prepare user stories for development.
- Stories and scenario sub-workflows. Distinguish the story as the deliverable Kanban work unit from the scenarios that guide its iterative BDD tasks, and describe simple ways to track both.
- Collaborative remote Example Mapping. Describe what a remote requirements workshop must preserve from Example Mapping and how online tools can support it.
- Specification as behavioral control. Explain why BDD becomes more relevant when agents write production code and automated tests, and why teams need feedback against the specification.
- Stakeholder agreement and scenario protection. Describe how discovery and formulation establish agreed specifications before agents code, and why automated scenarios must not be changed without stakeholder approval.
- Test fidelity and supplementary testing. Explain why agentic workflows need supplementary testing even when the specification is correct, and what Red/Green/Refactor can and cannot do about this risk.
- Fixed-Scope Specification Gaps. Explain why a fixed-scope specification cannot settle every implementation decision, and how leaving those decisions untracked causes trouble.
- Feature Preparation Through Example Mapping. Describe how a team can use Example Mapping before implementing each feature to clarify its rules and examples, compare it with its budget, and decide what scope to keep.
- Explicit Decisions in Living Documentation. Explain what living documentation adds to a fixed-scope project and what problem it does not eliminate.
- Scenarios linking specifications and tests. Explain how BDD scenarios begin as illustrative examples for shared understanding and can be extended with test cases to meet a testing strategy's coverage needs. Describe how their business-readable format links specifications and tests.
- Version-specific execution reports. Explain how executing versioned BDD scenarios can produce a report that records expected behavior, the tests used, and execution results for a particular product version.
What it builds on
- How to establish structured conversations (chapter 2) · Assumes the value of structured conversations involving different role perspectives.
- Formulation (chapter 1) · Introduces formulation as a BDD activity.
- Automation (chapter 1) · Introduces automation in the BDD approach.
- Testing (chapter 1) · Introduces testing as part of the BDD approach.
- Example Mapping in a nutshell (chapter 2) · The use of Example Mapping in structured conversations.
- Collecting examples (chapter 2) · Collecting examples during requirements discussions
- Will AI make BDD irrelevant? (chapter 1) · the earlier discussion of AI and BDD
- Discovery (chapter 1) · the role of discovery in BDD
Section by section
Introduction
This introduction explains that teams should adapt BDD to their local development context rather than follow a fixed process.
- Contextual BDD process design: Explain why a team should adapt its BDD process to its development method, organizational roles, and team members, then review and adjust that process as needed.
Why it matters: It helps your team make BDD work within its actual way of working instead of copying another team’s process.
Key terms: BDD, local context, development process, roles and responsibilities
4.1 The BDD approach
This section maps the connected activities of a BDD development cycle, showing when they happen, who participates, and what each produces.
- Story preparation and discovery: Trace how a selected user story moves into discovery: stakeholders prepare the story and candidate rules before a workshop, then business, development, and test perspectives discuss rules and examples to refine them.
Why it matters: It helps the team reach a shared understanding before turning examples into specifications. - Scenario formulation and business review: Explain how the team turns discovered examples into business-readable scenarios before implementation and has business representatives review them for correct behavior and terminology. Describe why scenario writers must make those scenarios worthwhile to review.
Why it matters: A scenario is useful only if both the delivery team and business colleagues can read it and check that it describes the right behavior. - Scenario-driven automation and implementation: Explain why the preferred order is to automate a scenario before implementing it, then write application code to make the failing scenario pass. Distinguish this from automating only after implementation.
Why it matters: The order of work lets specified behavior guide the code rather than merely checking it afterward. - Supplementary testing and release: Describe how testing beyond automated scenarios can begin as soon as a scenario is complete, and when the team can produce an installable release package.
Why it matters: It makes clear that a passing automated scenario is a point to start broader testing, not a substitute for it.
Key terms: user story, candidate rules, Discovery, requirements workshops, examples, Formulate, scenarios, Review, business readable, Automate
4.2 BDD in Scrum
Introduces Scrum’s sprint cycle and states that BDD works well within it.
- Scrum sprint workflow: Describe how Scrum prepares and selects user stories during a sprint, then reviews the results and discusses process improvements. State that BDD works well with Scrum without claiming that this section explains how to integrate them.
Why it matters: This sprint cycle provides the context for the BDD activities discussed next.
Key terms: sprints, user stories, sprint planning, sprint review/demo, sprint retrospective
4.2.1 Discovery
This section explains how to fit BDD discovery into Scrum meetings and why discussing examples makes those meetings more focused.
- Discovery Meetings in Scrum: Describe where BDD discovery fits in Scrum and how the team can schedule it according to access to the product owner.
Why it matters: The team can make room for discovery without depending on a single meeting schedule. - Examples Focus Discovery Discussions: Explain how discussing examples affects early requirements conversations and why scenario writing helped the team in the story finish sprint planning sooner.
Why it matters: Focusing on examples helps the team use its limited discussion time on valuable questions.
Key terms: requirements workshops, structured conversations, Example Mapping, sprint planning meeting, examples, outcomes, scenarios
4.2.2 Formulate
The section explains when and by whom Scrum teams should formulate scenarios, and how to review them without creating bottlenecks.
- Formulation in the story pipeline: Explain why Scrum teams should formulate scenarios as the first task in a story’s implementation pipeline rather than during a requirements workshop.
Why it matters: Separating discovery from careful wording gives the team shared understanding without making everyone spend workshop time editing scenarios. - Representative scenarios before full formulation: Describe how to stage formulation when the team has no automation experience in the relevant application area.
Why it matters: An initial sample can prevent the team from committing to wording that proves awkward to automate. - Small-group formulation and approval: Explain who typically formulates scenarios, how business review fits in, and why required approvals must be planned.
Why it matters: The team can keep formulation manageable while still checking that its scenarios reflect the business request. - AI-assisted human scenario review: Distinguish the preliminary checks AI can perform from the final human validation required before scenarios drive development.
Why it matters: Automated checks can speed review, but they cannot replace business judgment about whether a specification is right.
Key terms: formulation, requirements workshops, implementation pipeline, source control, representative examples, scenarios, automation, solution design, pair, developer
4.2.3 Aligning tasks to scenarios
This section explains how Scrum teams can use business-readable BDD scenarios to plan technical tasks and make progress visible through working behavior.
- Scenario Aligned Task Planning: Distinguish development tasks from examples and scenarios, and explain how a team can use scenarios to plan tasks. Describe why a task should relate to one scenario where practical, while recognizing that some tasks support several scenarios.
Why it matters: Scenario-aligned tasks connect the team's technical work to the behavior the story is meant to deliver. - Behavior Focused Implementation: Explain how starting implementation from a scenario keeps the team focused on expected behavior rather than unnecessary work.
Why it matters: Starting with the behavior helps the team spend effort on what the story actually needs. - Visible Functional Progress: Explain why completed end-to-end scenarios provide earlier feedback, allow manual testing to start, and communicate progress better than technical task completion or a percentage.
Why it matters: Showing working behavior gives the Product Owner and testers something useful to assess before the entire story is finished. - Scenarios As Simple Story Tasks: Describe when scenarios themselves can serve as tasks, or when a separate taskboard may add little value.
Why it matters: A small, clearly decomposed story may not need another layer of task tracking.
Key terms: tasks, examples, scenarios, functional breakdown, expected behavior, gold-plating, outside-in development approach, end-to-end, execution report, functional progress
4.3 BDD in Lean/Kanban
This section shows how to fit story-level BDD and scenario-level work into Kanban flow, with cautions about separating automation and using AI for process assistance.
- Kanban flow and discovery: Explain how Kanban’s work-in-progress limit affects when a team uses Example Mapping to prepare user stories for development.
Why it matters: It connects BDD discovery to the team’s actual capacity rather than treating it as a separate schedule. - Stories and scenario sub-workflows: Distinguish the story as the deliverable Kanban work unit from the scenarios that guide its iterative BDD tasks, and describe simple ways to track both.
Why it matters: It helps a team see real scenario progress without mistaking a partly completed story for a deliverable one. - Separate automation column tradeoff: Explain when a separate Kanban column for scenario automation may help and why separating that work needs caution.
Why it matters: A clearer board should not come at the cost of the feedback that makes BDD useful. - AI process assistance: Describe the administrative and progress-monitoring work that AI agents can assist with in a BDD development process.
Why it matters: Process assistance can reduce tracking effort and make delays easier to spot. - Agent access safeguards: Justify giving AI agents separate, constrained credentials when they can change project artifacts.
Why it matters: Separate credentials limit the damage an agent can cause and make its changes accountable.
Key terms: Kanban, lead time, work in progress (WIP), Example Mapping, user stories, scenarios, sub-workflow, story card, scenario automation, Kanban board
4.4 BDD in distributed teams
This section explains how distributed teams can preserve BDD collaboration through shared examples, visible scenario status, and remote requirements workshops.
- Shared examples across distance: Explain how concrete examples and appropriate online tools help distributed teams agree on system behavior despite physical and other barriers.
Why it matters: Shared examples give people in different locations something concrete to agree on and discuss. - Visible scenario implementation status: Describe how accessible scenario execution reports can improve cooperation and help testers and product owners decide what to do without waiting for individual status updates.
Why it matters: Visible status reduces the need to chase teammates for updates. - Collaborative remote Example Mapping: Describe what a remote requirements workshop must preserve from Example Mapping and how online tools can support it.
Why it matters: The tool matters less than keeping the remote workshop collaborative and its discoveries visible to everyone.
Key terms: concrete examples, agreed behavior, distributed teams, scenario implementation status, scenario execution reports, CI build, requirements workshops, Example Mapping, rules and examples, facilitator
4.5 BDD in agentic software development
The section explains how BDD specifications guide AI-generated software and why teams still need stakeholder review and supplementary testing.
- Specification as behavioral control: Explain why BDD becomes more relevant when agents write production code and automated tests, and why teams need feedback against the specification.
Why it matters: Faster generated code is valuable only if the team can check that it delivers the intended behavior. - Stakeholder agreement and scenario protection: Describe how discovery and formulation establish agreed specifications before agents code, and why automated scenarios must not be changed without stakeholder approval.
Why it matters: An agreed, protected specification gives the team a way to retain intended behavior as agents add features. - Test fidelity and supplementary testing: Explain why agentic workflows need supplementary testing even when the specification is correct, and what Red/Green/Refactor can and cannot do about this risk.
Why it matters: Passing automated tests cannot provide full confidence if those tests misrepresent the agreed scenarios.
Key terms: agentic AI, specification, feedback, discovery, formulation, vibe coding, scenarios, stakeholder, supplementary testing, exploratory tests
4.6 BDD in fixed-scope projects
The section explains how teams can use BDD to make decisions visible and guide feature development even when scope and budget are fixed.
- Fixed-Scope Specification Gaps: Explain why a fixed-scope specification cannot settle every implementation decision, and how leaving those decisions untracked causes trouble.
Why it matters: A signed-off specification does not remove the need to clarify and record decisions during development. - Feature Preparation Through Example Mapping: Describe how a team can use Example Mapping before implementing each feature to clarify its rules and examples, compare it with its budget, and decide what scope to keep.
Why it matters: Mapping a feature before building it helps the team make scope cuts without losing sight of the feature as a whole. - Explicit Decisions in Living Documentation: Explain what living documentation adds to a fixed-scope project and what problem it does not eliminate.
Why it matters: Visible, revisable decisions give the team and customer a better basis for handling corrections and change requests.
Key terms: fixed scope, specification document, implicit and untracked decisions, Example Mapping, example map, rules, illustrative examples, scenarios, living documentation, continuously validated living document
4.7 BDD in regulated environments
This section explains how business-readable BDD scenarios and execution reports can support traceability in regulated projects, while still requiring careful preparation for regulatory review.
- Regulated project traceability needs: Describe the three areas a regulated project's process generally needs to address: specification completeness and correctness, test coverage and strategy, and evidence of testing for a particular version.
Why it matters: These are the needs the section uses to evaluate what BDD can contribute. - Scenarios linking specifications and tests: Explain how BDD scenarios begin as illustrative examples for shared understanding and can be extended with test cases to meet a testing strategy's coverage needs. Describe how their business-readable format links specifications and tests.
Why it matters: The same readable scenarios can connect what the team agreed the software should do with how that behavior is checked. - Version-specific execution reports: Explain how executing versioned BDD scenarios can produce a report that records expected behavior, the tests used, and execution results for a particular product version.
Why it matters: A report tied to a product version helps make the relationship between requirements, tests, and results reviewable. - Regulatory documentation limits: Explain why BDD report generation still needs preparation for regulatory review and why readable, organized executable requirements do not eliminate the need for other documents.
Why it matters: Automated evidence is useful only if reviewers can understand it and it meets the project's formal documentation requirements.
Key terms: traceability, specification, testing strategy, scenarios, illustrative examples, business-readable, versioned, execution result, report, living documentation
4.8 Summary
Where this is used later
- BDD is for solving problems (chapter 5) · The earlier description of the BDD approach provides a contrast to explaining BDD through a business problem.
- Tracking scenario automation lifecycle with tags (chapter 10) · The BDD approach’s formulation, automation, and implementation work.
- Too many cooks (chapter 9) · Examines participation in scenario formulation.
- Automation proof-of-concept (chapter 12) · Develops the practical groundwork for scenario automation.
- Who does what and when (chapter 9) · The later discussion of who does what and when builds on this placement of formulation in the work.
- It is hard to get the product to a deliverable state (chapter 5) · The use of scenarios to align and organize work in Scrum.
- The one where the business is not involved (chapter 5) · The context of AI use in software development.
- Incremental specification (chapter 9) · The earlier discussion of BDD in agentic software development provides context for applying scenarios to AI-generated code.
Concepts explained in this chapter
- behavior-driven developmentAn activity that applies behavior-driven development principles during software development.
- formulationThe behavior-driven development practice of expressing understood behavior as precise scenarios.
- scenario reviewA collaborative examination of behavior scenarios to identify ambiguity, omissions, or errors and establish agreement before implementation.
- supplementary testingTesting activities that complement scenario-based automated checks, including manual and other specialized forms of evaluation.
- automationAutomation is the behavior-driven development practice of making specified scenarios executable so that software behavior can be checked automatically.
- scenarioA business-readable description of an example system behavior and its expected outcome.
- test-driven developmentA software development technique in which automated tests are written before implementation code and guide the design of the code.
- living documentationLiving documentation is documentation kept aligned with the current behavior of a software system through executable or continuously validated specifications.
- exampleA concrete instance illustrating an expected behavior or a possible outcome of a rule.
- taskA work unit representing work required to complete a user story, often recording a team's design or implementation decisions.
- Example MappingExample Mapping is a collaborative technique for clarifying a requirement by organizing its rules, examples, and open questions.
- discovery workshopA collaborative session for exploring and refining software requirements through structured conversation.
- test strategyA planned approach defining the testing activities, scope, and coverage needed to evaluate a software product.
- specificationA sufficiently complete description of a solution's required behavior and characteristics for a delivery team to design and implement it.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
