Chapter 1: What is BDD?
This introduction presents BDD as a way to turn an evolving conversation about business needs into a guide for development, while clarifying that BDD is not primarily about testing.
After this chapter you will be able to
- BDD as shared conversation. Explain why BDD treats software development as an ongoing conversation among users, business stakeholders, and the delivery team, rather than simply a coding task.
- Automated tests in BDD. Distinguish the role of automated tests in BDD and TDD from software testing as a primary purpose.
- Business Needs and Delivery Challenges. Explain why delivering software that solves business problems remains difficult, including challenges in understanding and communicating customer needs, demonstrating reliable results, and maintaining software over time.
- Limits of stakeholder requirements. Explain why a stakeholder requirement, even when it identifies a genuine need, is not yet detailed enough for the delivery team to design and implement the solution effectively.
- Consequences of communication gaps. Describe how clarifications or differing assumptions about business context can lead to rework or an implementation that misses the stakeholder’s intention, and explain why requirements need attention throughout development.
- Missing requirements-to-behavior link. Explain why a failing functional regression test can be hard to interpret when tests and documentation are not reliably connected to current requirements, and what the team must do instead.
- Costs of delayed feedback. Explain why teams need feedback before users and stakeholders give their ultimate verdict, and how waiting for regression-test results can increase rework and context-switching.
- Reliable and meaningful results. Describe why feedback must be reliable and easy to diagnose, and state the kind of feedback mechanism the section says is missing.
- BDD’s business and technical bridge. Explain how BDD relates to TDD while emphasizing collaboration between business and technical people and the links among requirements, documentation, tests, and the system.
- Behavior-focused test communication. Explain why early test naming could lose the connection to business requirements and how BDD’s creator sought to preserve that connection and make results readable to business representatives.
- Three BDD core practices. Trace how a user story moves through discovery, formulation, and automation, and describe what each practice contributes.
- User story as conversation placeholder. Explain why a user story is a placeholder for a conversation rather than a complete requirements document: it initially captures a potentially valuable increment of functionality and defers detailed requirements gathering until the story is prioritized.
- Candidate rules and initial scope. Describe how candidate rules accompany a user story to outline expected scope, while remaining subject to scrutiny during discovery. Use the delivery-address story to illustrate the distinction between customer value and an initial rule.
- Examples in discovery workshops. Explain how the team uses a structured conversation and examples to explore a user story’s expected behavior, clarify its rules, and expose assumptions or complexities early.
- Shared understanding and story changes. Describe the main outcome of discovery and why discussing examples may change the story or its rules.
- Discovery examples as specifications. Explain how formulation turns examples from discovery into scenarios that both business and technical people can understand and that precisely express required system behavior.
- Separate delivery-team formulation. Justify doing formulation separately from discovery, with delivery-team members drafting scenarios and a later review checking their understanding with the business.
- Scenario tools and team code. Explain how a scenario automation tool uses scenario text and what the team must supply.
- Red green refactor cycle. Trace how an automated scenario guides implementation, including where TDD may fit.
- Verified living documentation. Explain how running automated scenarios keeps documentation connected to implementation and what a failure can mean.
- Shared responsibility for quality. Explain how BDD supports agile testing by shifting attention toward preventing defects and making code quality the responsibility of the whole delivery team.
- Continuing value of testers. Justify why teams adopting BDD should retain skilled testers, including testers with domain knowledge, and describe the section’s approach to cross-skilling.
- Shift toward exploratory verification. Explain why verification remains necessary under BDD and how automation changes the balance between manual regression testing and exploratory testing.
- Examples as an executable bridge. Explain how examples uncovered during discovery become an executable check of whether the delivery team implemented the behavior stakeholders required, giving both sides confidence.
- Overlapping Approach Names. Explain why a team should not let distinctions among ATDD, BDD, and Specification by Example distract it from the underlying techniques.
- Business collaboration in BDD. Explain why frequent collaboration between business people and the delivery team is foundational to BDD.
- Limits of Isolated Automation. Explain why test-team-only automation cannot deliver the full benefits of BDD, even if it reduces some testing effort. Describe how isolation affects the scenarios, their timing, and the automation code.
- Readable specifications for business users. Explain why long, rambling scenarios with meaningless names are a problem: business people are unlikely to use them to understand the system, so much of the effort of formulation is wasted.
- Scenario automation code quality. Explain why BDD scenario automation code needs production-like quality: it must both interact with the system and support natural-sounding scenarios.
- Specifications as AI guardrails. Explain why specifications remain valuable when AI writes software: they state the intended behavior and help prevent unexpected changes to existing behavior.
- Human knowledge and agent context. Describe what humans and context contribute to agentic AI work: people uncover and communicate domain requirements, while agents need guidance that extends beyond the next specification.
- BDD through illustrative examples. Explain that BDD uses illustrative scenarios and examples to understand, document, implement, and verify business requirements.
- Realistic commitment to change. Justify why adopting BDD should account for the commitment and investment needed for change, rather than trying to do too much too fast or merely renaming existing practices.
- Incremental BDD adoption. Explain why BDD should be introduced through small changes in one team, with results observed before adoption is broadened.
- Business needs before automation. Describe the recommended order for adopting BDD practices and why discovery alone may be a worthwhile stopping point.
- Meaningful team collaboration. Distinguish collaboration from simply passing a story, software, or tickets between roles. Explain that collaboration involves people working respectfully toward an outcome through meaningful interaction and exchange of useful information.
- Criteria for adopting an approach. State the three criteria for an approach that claims to improve software development: a clear reason it could address your challenges, adaptability to your context, and evidence over time that it delivers value. Explain that the authors believe BDD can meet these criteria when understood and fitted to the organization.
- Conditions for successful BDD adoption. Explain why BDD is simple but not easy to adopt, including the participation and code-quality commitments needed for discovery, formulation, and automation.
- Limits and value of BDD. Describe why BDD is not a silver bullet and how a team should weigh its possible benefits against the problems it actually needs to solve.
Section by section
Introduction
This introduction presents BDD as a way to turn an evolving conversation about business needs into a guide for development, while clarifying that BDD is not primarily about testing.
- BDD as shared conversation: Explain why BDD treats software development as an ongoing conversation among users, business stakeholders, and the delivery team, rather than simply a coding task.
Why it matters: This explains why BDD involves more than the people writing code. - Automated tests in BDD: Distinguish the role of automated tests in BDD and TDD from software testing as a primary purpose.
Why it matters: It prevents the use of automated tests from being mistaken for BDD's main purpose.
Key terms: socio-technical conversation, Behavior-Driven Development, precise, testable, Test-Driven Development, automated tests
1.1 The missing links between business needs and software delivery
This section frames the persistent gap between business needs and software delivery as a set of challenges spanning the development process.
- Business Needs and Delivery Challenges: Explain why delivering software that solves business problems remains difficult, including challenges in understanding and communicating customer needs, demonstrating reliable results, and maintaining software over time.
Why it matters: These challenges explain why connecting customer needs to delivered software requires attention throughout development.
Key terms: business problems, customer’s needs, software delivery, maintainability
1.1.1 Insufficient requirements
This section explains why high-level stakeholder requirements need ongoing communication and management to become a solution that meets the stakeholder’s intentions.
- Limits of stakeholder requirements: Explain why a stakeholder requirement, even when it identifies a genuine need, is not yet detailed enough for the delivery team to design and implement the solution effectively.
Why it matters: A genuine customer need can still leave the team without enough information to build the right solution. - Consequences of communication gaps: Describe how clarifications or differing assumptions about business context can lead to rework or an implementation that misses the stakeholder’s intention, and explain why requirements need attention throughout development.
Why it matters: Checking understanding throughout development helps avoid building something that looks right but disappoints the stakeholder.
Key terms: requirement, stakeholder, business representatives, delivery team, clarification, business context, rework, management of requirements
1.1.2 Unreliable documentation
This section explains why maintenance becomes difficult when documentation and tests do not reliably connect delivered behavior to current stakeholder needs.
- Regression checks during maintenance: Explain why changes to delivered software need to be checked against existing behavior, regardless of whether the change addresses business needs, defects, or a platform move.
Why it matters: Regression checks help a team notice when a maintenance change affects behavior it did not intend to change. - Missing requirements-to-behavior link: Explain why a failing functional regression test can be hard to interpret when tests and documentation are not reliably connected to current requirements, and what the team must do instead.
Why it matters: A reliable connection to current requirements helps teams decide what a test failure means instead of repeatedly rediscovering intended behavior.
Key terms: maintainability, regression tests, unintended side-effects, stakeholder needs, current requirements, functional regression test, reverse engineer, automated link
1.1.3 Slow feedback
This section explains how delayed, unreliable, or unclear feedback about system behavior creates rework and delays, and why teams need earlier, meaningful results.
- Costs of delayed feedback: Explain why teams need feedback before users and stakeholders give their ultimate verdict, and how waiting for regression-test results can increase rework and context-switching.
Why it matters: Getting results sooner can prevent a defect from disrupting work the team has already started. - Reliable and meaningful results: Describe why feedback must be reliable and easy to diagnose, and state the kind of feedback mechanism the section says is missing.
Why it matters: A quick result helps less if the team cannot trust it or tell which requirement is affected.
Key terms: feedback loops, manual regression tests, context-switching, flaky test, meaningful diagnostic information, granularity of the requirement
1.2 Origins of BDD
This section explains how BDD grew out of TDD to keep tests connected to expected business behavior and understandable to business people.
- BDD’s business and technical bridge: Explain how BDD relates to TDD while emphasizing collaboration between business and technical people and the links among requirements, documentation, tests, and the system.
Why it matters: This distinction explains why BDD involves more than writing automated tests. - The TDD feedback cycle: Trace the TDD cycle from writing an automated test before code through a failing test, just enough code to pass, and refactoring before the next test.
Why it matters: The cycle provides the TDD background from which BDD developed. - Behavior-focused test communication: Explain why early test naming could lose the connection to business requirements and how BDD’s creator sought to preserve that connection and make results readable to business representatives.
Why it matters: It shows why readable descriptions and results help business people stay engaged with expected behavior.
Key terms: Behavior Driven Development (BDD), Test Driven Development (TDD), collaboration, Test-Driven Development (TDD), Red, Green, refactoring, expected behavior, business requirements, business-readable
1.3 How BDD works
This section explains how each user story moves through discovery, formulation, and automation to contribute to working software.
- Three BDD core practices: Trace how a user story moves through discovery, formulation, and automation, and describe what each practice contributes.
Why it matters: The three practices connect a conversation about a story to scenarios that can guide and check its implementation. - Role of user stories: Distinguish a user story from a requirement and explain its role in starting the BDD flow.
Why it matters: A story gives the team a valuable piece of functionality to explore without pretending its details are already settled. - BDD and software delivery: Distinguish BDD’s contribution to working software from the other work needed to deliver it.
Why it matters: This keeps the role of BDD clear without confusing scenario automation with the whole of software delivery.
Key terms: discovery, formulation, automation, examples, business-readable scenarios, user stories, stakeholders, requirements, working software, production code
1.3.1 Start with a user story
Introduces a user story as a starting point for conversation, with candidate rules that give initial scope but need scrutiny during discovery.
- User story as conversation placeholder: Explain why a user story is a placeholder for a conversation rather than a complete requirements document: it initially captures a potentially valuable increment of functionality and defers detailed requirements gathering until the story is prioritized.
Why it matters: This keeps the team from treating an initial story as a finished specification. - Candidate rules and initial scope: Describe how candidate rules accompany a user story to outline expected scope, while remaining subject to scrutiny during discovery. Use the delivery-address story to illustrate the distinction between customer value and an initial rule.
Why it matters: Separating the desired outcome from tentative rules makes it easier to spot what still needs discussion.
Key terms: user story, placeholder for a conversation, candidate rules, rule, discovery
1.3.2 Discovery
Discovery uses a team requirements workshop to turn a user story into concrete examples and a shared understanding of what should be delivered.
- Examples in discovery workshops: Explain how the team uses a structured conversation and examples to explore a user story’s expected behavior, clarify its rules, and expose assumptions or complexities early.
Why it matters: Concrete examples help the team find different interpretations before they become delivery problems. - Shared understanding and story changes: Describe the main outcome of discovery and why discussing examples may change the story or its rules.
Why it matters: A workshop is valuable when it aligns the team on the requirements, even if that means changing the original story.
Key terms: discovery, requirements workshop, structured conversation, examples, rules, shared understanding, detailed requirements, story
1.3.3 Formulation
This section explains how formulation turns discovery examples into business-readable scenarios that specify required behavior, and why teams do it separately from discovery.
- Discovery examples as specifications: Explain how formulation turns examples from discovery into scenarios that both business and technical people can understand and that precisely express required system behavior.
Why it matters: Scenarios let the people requesting software and the people building it discuss the same required behavior. - Scenario language and structure: Describe the typical Given/When/Then form of a scenario and relate it to the section’s delivery-address example and Gherkin.
Why it matters: This form keeps a required behavior readable while leaving a path to automation. - Separate delivery-team formulation: Justify doing formulation separately from discovery, with delivery-team members drafting scenarios and a later review checking their understanding with the business.
Why it matters: Separating drafting from discovery preserves the pace of conversation while still giving the business a chance to check the result.
Key terms: formulation, discovery, business-readable scenario, required system behavior, Given, When, Then, Gherkin, scenario, delivery team
1.3.4 Automation
This section explains how teams automate formulated scenarios to guide implementation, get fast feedback, and keep specifications connected to working software.
- Scenario tools and team code: Explain how a scenario automation tool uses scenario text and what the team must supply.
Why it matters: It separates what the tool does from the automation work the team must do. - Red green refactor cycle: Trace how an automated scenario guides implementation, including where TDD may fit.
Why it matters: The failing scenario makes the expected behavior a guide for implementation rather than just a check afterward. - Developer feedback safety net: Explain why developers should be able to run relevant automated scenarios before committing changes.
Why it matters: Quick checks let developers address problems while the change is still fresh. - Verified living documentation: Explain how running automated scenarios keeps documentation connected to implementation and what a failure can mean.
Why it matters: A failing scenario prompts the team to check both the software and the specification instead of trusting either blindly.
Key terms: scenario automation tool, step, automation code, red, green, refactoring, TDD, rule, fast feedback, safety net
1.3.5 Testing
This section explains how BDD changes the focus of testing while preserving testers’ expertise and the need for human verification.
- Shared responsibility for quality: Explain how BDD supports agile testing by shifting attention toward preventing defects and making code quality the responsibility of the whole delivery team.
Why it matters: BDD changes who takes responsibility for quality, not whether testing matters. - Continuing value of testers: Justify why teams adopting BDD should retain skilled testers, including testers with domain knowledge, and describe the section’s approach to cross-skilling.
Why it matters: Keeping testers’ expertise in the team helps BDD improve quality without losing valuable skills or domain knowledge. - Shift toward exploratory verification: Explain why verification remains necessary under BDD and how automation changes the balance between manual regression testing and exploratory testing.
Why it matters: Automation frees testers to investigate kinds of correctness that automated checks alone cannot establish.
Key terms: BDD, agile testing, code quality, test automation, discovery, domain knowledge, cross-skilling, verification, manual regression testing, exploratory verification
1.3.6 BDD is a bridge
This section explains how discovered, formulated, and automated examples connect stakeholder requirements to delivered software throughout the system’s life.
- Examples as an executable bridge: Explain how examples uncovered during discovery become an executable check of whether the delivery team implemented the behavior stakeholders required, giving both sides confidence.
Why it matters: The same examples help stakeholders and the delivery team check that they mean the same thing by the delivered behavior. - Confidence across the system lifetime: Describe how automated examples help preserve confidence as the system changes, both by guarding against regressions and by documenting its behavior.
Why it matters: The examples remain useful after initial delivery, when the system and the people responsible for it change.
Key terms: discovery, formulated, automated, executable verification, side effects, regressions, persistent documentation, maintainability
1.4 Common challenges when adopting BDD
This introduction notes that widespread BDD adoption does not guarantee success and previews a discussion of common challenges.
1.4.1 Naming is hard
This section explains why teams should focus on the techniques behind BDD rather than debates over names for similar approaches.
- Overlapping Approach Names: Explain why a team should not let distinctions among ATDD, BDD, and Specification by Example distract it from the underlying techniques.
Why it matters: Your team can concentrate on using the techniques rather than settling a terminology debate.
Key terms: Acceptance Test Driven Development (ATDD), Behavior Driven Development (BDD), Specification by Example (SbE)
1.4.2 BDD without the business
This section explains why BDD loses much of its value without business stakeholder involvement, and when a Product Owner can represent that perspective.
- Business collaboration in BDD: Explain why frequent collaboration between business people and the delivery team is foundational to BDD.
Why it matters: Business involvement helps keep specifications connected to what the business needs. - Product Owner stakeholder role: Distinguish a Product Owner who can act as the business stakeholder from one who holds the title without the necessary knowledge and responsibility.
Why it matters: A job title alone does not guarantee the business perspective BDD needs.
Key terms: business people, delivery team, iterative refinement of specifications, business-readable language, Product Owners, business stakeholder
1.4.3 Automation in isolation
This section explains why automating BDD scenarios without business and developer collaboration delivers limited value.
- Limits of Isolated Automation: Explain why test-team-only automation cannot deliver the full benefits of BDD, even if it reduces some testing effort. Describe how isolation affects the scenarios, their timing, and the automation code.
Why it matters: Automation alone does not replace the collaboration that makes scenarios useful for specifying and guiding software development.
Key terms: automation in isolation, scenarios, system specifications, low-level automation steps
1.4.4 Unreadable documentation
Unreadable scenarios undermine the value of BDD specifications for business people and customers.
- Readable specifications for business users: Explain why long, rambling scenarios with meaningless names are a problem: business people are unlikely to use them to understand the system, so much of the effort of formulation is wasted.
Why it matters: Readable scenarios let the people they are written for benefit from the specification.
Key terms: scenarios, specification, formulation, business-readable language
1.4.5 Unmaintainable automation
This section explains why BDD scenario automation code needs to be both understandable and maintainable.
- Scenario automation code quality: Explain why BDD scenario automation code needs production-like quality: it must both interact with the system and support natural-sounding scenarios.
Why it matters: Readable scenarios are harder to sustain if the code behind them is difficult to maintain.
Key terms: scenario automation, automation code, idiomatic usage of natural language
1.5 Will AI make BDD irrelevant?
The section argues that AI may change software development, but BDD remains valuable for guiding AI-generated work with human domain knowledge, specifications, context, and controlled practices.
- Specifications as AI guardrails: Explain why specifications remain valuable when AI writes software: they state the intended behavior and help prevent unexpected changes to existing behavior.
Why it matters: A generated solution still needs a clear, checkable account of the behavior it is meant to deliver and preserve. - Human knowledge and agent context: Describe what humans and context contribute to agentic AI work: people uncover and communicate domain requirements, while agents need guidance that extends beyond the next specification.
Why it matters: Giving an agent a task is not a substitute for discovering the requirements or supplying the context behind them. - Small increments and automated checks: Explain why small increments and automated process checks help control AI-assisted development.
Why it matters: Keeping changes understandable and checking shared standards makes AI-assisted work easier to control. - SDD relationship to BDD: Distinguish Specification-Driven Development from a replacement for BDD, and describe how BDD concepts can apply to technical as well as behavioral specifications.
Why it matters: This distinction prevents treating technical specifications and BDD practices as mutually exclusive.
Key terms: specifications, guardrail, business-readable software specifications, domain knowledge, context, guidance, harness, small steps, process adherence, coding or design standards
1.6 How to begin implementing BDD
This section defines BDD in terms of examples and scenarios and cautions against adopting it faster than an organization can support.
- BDD through illustrative examples: Explain that BDD uses illustrative scenarios and examples to understand, document, implement, and verify business requirements.
Why it matters: This gives the team a shared description of what BDD is for. - Realistic commitment to change: Justify why adopting BDD should account for the commitment and investment needed for change, rather than trying to do too much too fast or merely renaming existing practices.
Why it matters: Treating adoption as real change helps avoid a superficial transformation that fails to deliver value.
Key terms: Behavior Driven Development, business requirements, illustrative scenarios and examples, commitment, investment, change, agile “transformations”
1.6.1 Evolution, not revolution
The section recommends introducing BDD through small, collaborative experiments that begin with business needs and discovery rather than an organization-wide rollout.
- Incremental BDD adoption: Explain why BDD should be introduced through small changes in one team, with results observed before adoption is broadened.
Why it matters: A small trial lets a team respond to what actually happens before committing more of the organization. - Business needs before automation: Describe the recommended order for adopting BDD practices and why discovery alone may be a worthwhile stopping point.
Why it matters: The team can gain value from clearer requirements without taking on automation before it is useful or practical. - Cross-role collaboration focus: Explain why early BDD changes should improve how different roles work together.
Why it matters: A change in how roles collaborate addresses the part of work this section identifies as central to BDD.
Key terms: experiment, proof of concept, iterations, business needs, user stories, discovery, formulation, automation, interfaces between different roles, collaboration
1.6.2 Collaboration
This section defines collaboration as meaningful, respectful exchange and argues that roles may need to change to make it possible.
- Meaningful team collaboration: Distinguish collaboration from simply passing a story, software, or tickets between roles. Explain that collaboration involves people working respectfully toward an outcome through meaningful interaction and exchange of useful information.
Why it matters: This distinction helps a team recognize when its handoffs are replacing collaboration. - Roles that enable collaboration: Explain why role descriptions or organizational structure may need to change when a product owner cannot reliably spend time working with the delivery team.
Why it matters: Collaboration needs time and responsibilities that make working together possible.
Key terms: collaboration, meaningful interaction, exchange of useful information, role descriptions, organizational structure, roles and responsibilities, product owner, delivery team
1.6.3 Opinions have context
This section explains why claims that BDD failed need context and gives criteria for judging whether a software-development approach is worth adopting.
- Context behind BDD failures: Explain why a report that BDD did not work is insufficient on its own: it does not say what was tried or what failed, and factors such as organizational fit, team buy-in, or over-promising may matter.
Why it matters: Context helps you learn from someone else’s experience without assuming your team will have the same result. - Criteria for adopting an approach: State the three criteria for an approach that claims to improve software development: a clear reason it could address your challenges, adaptability to your context, and evidence over time that it delivers value. Explain that the authors believe BDD can meet these criteria when understood and fitted to the organization.
Why it matters: These criteria give your team a way to decide whether BDD is helping rather than adopting or rejecting it on reputation alone.
Key terms: BDD, team buy-in, configurable to your context, demonstrably delivers value
1.6.4 Free lunch or silver bullet?
BDD can improve software delivery, but adopting it takes sustained collaboration and technical care, and it cannot solve every problem.
- Conditions for successful BDD adoption: Explain why BDD is simple but not easy to adopt, including the participation and code-quality commitments needed for discovery, formulation, and automation.
Why it matters: These commitments make the difference between adopting BDD practices and merely saying the team uses BDD. - Limits and value of BDD: Describe why BDD is not a silver bullet and how a team should weigh its possible benefits against the problems it actually needs to solve.
Why it matters: Realistic expectations help a team decide whether the effort of adopting BDD addresses its most pressing problems.
Key terms: BDD, discovery, formulation, automation, code quality, silver bullet, less waste, fewer defects, reduced rework, faster feedback
1.7 Summary
Where this is used later
- Living documentation (chapter 6) · The discussion of living documentation builds on the need to keep documented expectations connected to the implemented system.
- Understandable diagnostics (chapter 12) · The need for understandable diagnostics motivates this automation principle.
- Evolving with fast feedback (chapter 12) · The need for fast feedback motivates this automation principle.
- BDD on legacy projects (chapter 11) · The earlier account of how BDD works.
- Rules vs. examples (chapter 3) · Starting BDD work with a user story.
- User stories are not the same as features (chapter 10) · Introduces starting BDD work with a user story.
- Collecting examples (chapter 2) · Develops the practice of collecting examples during discovery.
- A useful meeting (chapter 2) · Examines what makes a requirements discussion useful.
Concepts explained in this chapter
- behavior-driven developmentAn activity that applies behavior-driven development principles during software development.
- scenarioA business-readable description of an example system behavior and its expected outcome.
- formulationThe behavior-driven development practice of expressing understood behavior as precise scenarios.
- automationAutomation is the behavior-driven development practice of making specified scenarios executable so that software behavior can be checked automatically.
- living documentationLiving documentation is documentation kept aligned with the current behavior of a software system through executable or continuously validated specifications.
- automated testingThe execution of software tests by programmed tools or scripts rather than manually.
- exampleA concrete instance illustrating an expected behavior or a possible outcome of a rule.
- user storyA user story is a concise requirement description expressing desired software behavior from a user's perspective.
- collaborationCollaboration is a cooperative working relationship in which relevant participants jointly discover, formulate, and refine software behavior.
- scenario automation toolSoftware that supports automating scenarios by connecting human-readable behavior descriptions to executable automation.
- discovery workshopA collaborative session for exploring and refining software requirements through structured conversation.
- shared understandingA common interpretation of requirements and expected behavior held by the members of a team.
- business ruleA business constraint governing payment when a customer collects an order.
- documentationDocumentation is recorded information describing a system and its behavior for reference and maintenance.
- test stepAn individual action or instruction within a software test procedure.
- specificationA sufficiently complete description of a solution's required behavior and characteristics for a delivery team to design and implement it.
- GherkinA domain-specific language for writing human-readable behavior specifications using constructs such as Given, When, and Then.
- test-driven developmentA software development technique in which automated tests are written before implementation code and guide the design of the code.
- manual test scriptA written sequence of instructions for a person to execute a software test manually.
- maintainabilityMaintainability is the ease with which software can be understood, modified, corrected, or enhanced.
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.
