Behavior-driven development
Behavior-driven development is a collaborative software development practice that specifies and verifies desired behavior through examples expressed in terms understandable to stakeholders.
BDD in Action, Second Edition
BDD is a collection of collaborative practices for discovering business needs and obtaining automated feedback that implemented features meet agreed expectations.
- How it is used
- Aligns feature delivery with business goals through shared examples and automated feedback on expected behavior.
- How deep it goes
- Works through goal discovery, collaborative examples, scenarios, acceptance automation, and outside-in implementation; the introductory walkthrough defers a full technology-stack example.
- Examples
- Uses train-departure scenarios and password-strength examples to uncover missing conditions and sharpen acceptance criteria.
- What you can do after
- Practice/perform collaborative feature discovery, formulate executable acceptance criteria, and use automated checks to guide implementation and reduce regression risk.
Read how BDD in Action, Second Edition explains behavior-driven development →
Effective Behavior-Driven Development
An activity that applies behavior-driven development principles during software development.
- How it is used
- Connects business requirements to software delivery through shared examples, reviewed scenarios, and automated feedback.
- How deep it goes
- Details discovery, formulation, automation, and the surrounding delivery activities; leaves initial story gathering outside its scope.
- Examples
- Uses a delivery-address change story to surface questions about order status and how far an address may change.
- What you can do after
- Practice/perform discovery, scenario review, and automation to guide new behavior and detect divergence from agreed expectations.
Read how Effective Behavior-Driven Development explains behavior-driven development →
Build Financial Software with Generative AI (From Scratch)
Behavior-driven development is a software-development and testing practice that specifies expected behavior through human-readable examples accessible to technical and nontechnical stakeholders.
- How it is used
- Uses collaborative behavior scenarios as acceptance criteria and to guide development of an ACH processing application.
- How deep it goes
- Walks through feature files, step definitions, fixtures, assertions, and debugging, while noting that initial scenarios cover only a fraction of requirements.
- Examples
- Uses ACH file-listing scenarios, invalid-file debugging, generated test files, and transaction search to illustrate BDD.
- What you can do after
- Apply it via pytest-bdd to write feature scenarios, connect step definitions, and check API behavior.
Claude at Work
Behavior-driven development is a software development technique that specifies and validates behavior through examples expressed in a shared natural-language format.
- How it is used
- Uses BDD to guide staged implementation and acceptance review of messaging features built with Claude Code.
- How deep it goes
- Details planning, scenario approval, failing-test checks, implementation, and slice acceptance, while leaving lower-level implementation details to plans.
- Examples
- Uses live message delivery and channel creation scenarios to illustrate user-visible behavior.
- What you can do after
- Apply it with Claude Code by reviewing Gherkin scenarios, approving implementation, and checking tests and deployed slices.
Read how Claude at Work explains behavior-driven development →
Shipping Go: Develop, deliver, discuss, design, and go again
Behavior-driven development is a software development approach that specifies and verifies behavior in terms of examples meaningful to stakeholders.
- How it is used
- Turns stakeholder-readable feature requirements into behavior-driven tests for a translation service.
- How deep it goes
- Explains Given–When–Then and Gherkin through a translation scenario, but does not show Go step implementations in the supplied evidence.
- Examples
- Uses translation cases for capitalization, spacing, and unsupported inputs, plus a Gherkin scenario translating “hello” into German.
- What you can do after
- Apply it via Gherkin and a Go runner to check a feature against stakeholder-readable requirements.
Build High Value Software Systems
A development practice that specifies and tests software behavior in a form intended to be readable by both technical and non-technical stakeholders.
- How it is used
- Aligns business and development by making tested behavior readable to non-technical stakeholders.
- How deep it goes
- Defines the stakeholder-facing goal, illustrates a feature file, and weighs maintenance costs without detailing implementation mechanics.
- Examples
- Shows a subscription purchase scenario covering confirmation, premium-account upgrade, and compliance transaction capture.
- What you can do after
- Review behavior scenarios with business stakeholders and surface missing requirements before building features.
Read how Build High Value Software Systems explains behavior-driven development →
Django in Action
Behavior-driven development is a software development approach that specifies and tests requirements-level behavior before or alongside implementation.
- How it is used
- Uses requirements-level tests to define desired software behavior before implementation.
- How deep it goes
- Explains the test-first cycle and distinguishes behavioral scope, but defers detailed tools and implementation techniques.
- Examples
- Uses requirements-level tests and a hierarchy contrasting unit, integration, behavioral, and UI tests.
- What you can do after
- Apply BDD by specifying behavior in tests, implementing against those tests, and checking completion through passing results.
Read how Django in Action explains behavior-driven development →
Spec-Driven Development
Behavior-driven development is a software development practice that specifies system behavior collaboratively using examples and shared language.
- How it is used
- Structures collaborative intent articulation before AI coding by building shared understanding through acceptance criteria.
- How deep it goes
- Centers collaborative acceptance criteria and shared scenarios rather than Gherkin syntax as an end in itself.
- Examples
- Uses a password-reset user story and scenarios for session invalidation and 30-minute reset-link validity.
- What you can do after
- Practice turning a user need into collaboratively authored, verifiable behavior scenarios.
Read how Spec-Driven Development explains behavior-driven development →
Also covered in
- Developer Experience on KubernetesIn early access (MEAP)
- The Art of Unit Testing 3e
- Practices of the Python Pro
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
What to know first
- test-driven developmentTest-driven development is a software development practice in which tests specify expected behavior and guide incremental implementation, typically being written before the corresponding code.
- acceptance criteriaAcceptance criteria are verifiable conditions that a requirement, feature, or deliverable must satisfy to be considered acceptable or complete.
- end-to-end testingEnd-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.
Related concepts
- automationhas part · Automation is the execution of tasks or processes by machines or software with reduced direct human intervention.
- discoveryhas part · Discovery is the process of identifying, locating, or examining information, entities, problems, or opportunities relevant to a particular purpose.
- formulationhas part · The behavior-driven development practice of expressing understood behavior as precise scenarios.
- Gherkincontrasts with · Gherkin is a structured, human-readable domain-specific language for expressing software behavior as features and scenarios with steps such as Given, When, and Then.
- implementationhas part · Implementation is the process or concrete realization of a design, specification, or requirement as executable code or operational behavior.
- specification-driven developmentcontrasts with · Specification-driven development is a software development approach in which an explicit specification guides the planning, implementation, and verification of software.
Questions about behavior-driven development
What is behavior-driven development?
Behavior-driven development is a collaborative software development practice that specifies and verifies desired behavior through examples expressed in terms understandable to stakeholders.
Which Manning books explain behavior-driven development?
BDD in Action, Second Edition, Effective Behavior-Driven Development, Build Financial Software with Generative AI (From Scratch), Claude at Work, Shipping Go: Develop, deliver, discuss, design, and go again, Build High Value Software Systems, Django in Action and Spec-Driven Development.
What should I know before learning behavior-driven development?
Manning books that teach behavior-driven development usually introduce test-driven development, acceptance criteria, end-to-end testing and Java first.
What is the difference between behavior-driven development and Gherkin?
Behavior-driven development is a collaborative software development practice that specifies and verifies desired behavior through examples expressed in terms understandable to stakeholders. Gherkin is a structured, human-readable domain-specific language for expressing software behavior as features and scenarios with steps such as Given, When, and Then.
What are the parts of behavior-driven development?
Behavior-driven development includes automation, discovery, formulation and implementation.
What is behavior-driven development also called?
Behavior-driven development is also called BDD.
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.







