# Behavior-driven development

Behavior-driven development is a software development process that uses concrete examples to guide teams from concept through implementation.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Breakpoint 2026 Speaker Spotlight: Andrew Knight

DevFeed: [Breakpoint 2026 Speaker Spotlight: Andrew Knight](<https://devfeed.tech/articles/breakpoint-2026-speaker-spotlight-andrew-knight-12620.md>)

Original publisher: [Read original article](<https://www.browserstack.com/blog/breakpoint-2026-speaker-spotlight-andrew-knight/>)

Author: Shweta Chhillar

Published: 2026-05-08T10:14:54Z

Content type: article

Language: en

Sources: [BrowserStack Blog](<https://devfeed.tech/sources/browserstack-blog.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [Selenium](<https://devfeed.tech/topics/selenium.md>), [Playwright](<https://devfeed.tech/topics/playwright.md>), [MCP Server](<https://devfeed.tech/topics/mcp-server.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [automation](<https://devfeed.tech/tags/automation.md>), [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [breakpoint-spotlight](<https://devfeed.tech/tags/breakpoint-spotlight.md>), [browser](<https://devfeed.tech/tags/browser.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [qa](<https://devfeed.tech/tags/qa.md>), [quality-engineering](<https://devfeed.tech/tags/quality-engineering.md>), [selenium](<https://devfeed.tech/tags/selenium.md>), [software](<https://devfeed.tech/tags/software.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [testing](<https://devfeed.tech/tags/testing.md>), [webdriver](<https://devfeed.tech/tags/webdriver.md>)

### AI overview

This speaker spotlight discusses how Andrew Knight combines open-source advocacy with enterprise software testing. It focuses on AI-powered test generation, behavior-driven development, context engineering, human oversight, and tools such as Selenium WebDriver, Playwright AI tooling, CLI skills, and an MCP server.

### Source excerpt

Explore how Andrew Knight is using AI, behavior-driven development, and context engineering to reshape enterprise software testing at BrowserStack Breakpoint 2026. This speaker spotlight dives into AI-powered QA, test automation, and the future of modern quality engineering.

## Leveraging Kotlin for Tests

DevFeed: [Leveraging Kotlin for Tests](<https://devfeed.tech/articles/leveraging-kotlin-for-tests-25968.md>)

Original publisher: [Read original article](<https://jossiwolf.medium.com/leveraging-kotlin-for-tests-311bfd8335ee?source=rss-8efc0359e234------2>)

Author: Jossi Wolf

Published: 2021-12-01T15:00:03Z

Content type: tutorial

Language: en

Sources: [Stories by Jossi Wolf on Medium](<https://devfeed.tech/sources/stories-by-jossi-wolf-on-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Cucumber](<https://devfeed.tech/topics/cucumber.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [bdd](<https://devfeed.tech/tags/bdd.md>), [given-when-then](<https://devfeed.tech/tags/given-when-then.md>), [junit](<https://devfeed.tech/tags/junit.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

This article explains how Kotlin language features and naming patterns can improve test readability. It covers the Given/When/Then pattern, meaningful test names, and using Kotlin backtick function names to make tests clearer.

### Source excerpt

Writing tests can be an important part of developing applications. Whether unit tests, integration tests or others, Kotlin's language features and clever naming patterns can help us increase the readability of tests. The patterns suggested here aren't new or innovative; rather they are more modern adaptions of well-established practices. I learned about these adaptions from my lovely colleague Volodymyr Galandzij who did fantastic work in setting up the testing framework in a codebase we worked on together. Given/When/Then You may have heard of the Given/When/Then pattern -- also known as the Cucumber/Gherkin syntax -- if you have written tests before, or you might even recognize it from Jira tickets. Originally introduced as a part of BDD (Behavior Driven Development), similar patterns like the Four-Phase Test (you'll see some similarities to JUnit here) have existed for a good amount of time. Martin Fowler gives a good small summary of all of this in his article about the Given/When/Then pattern: The essential idea is to break down writing a scenario (or test) into three sections:The given part describes the state of the world before you begin the behavior you're specifying in this scenario. You can think of it as the pre-conditions to the test.The when section is that behavior that you're specifying.Finally the then section describes the changes you expect due to the specified behavior. Regardless of the testing philosophy you follow, there's a good chance that the Given/When/Then pattern can be applied to your tests. But how does this look in practice? I heard that adding a featured image helps increase clicks. Does it work? Who knows! If it does, thank you, Sigmund on Unsplash!Test Names I argue that test names are one of the most important parts of writing good tests. The name of the test should help you understand what the test does. One quality of a good test is that it fails when the actual outcome is different from the expected outcome. When a test fails, it

## Other Driven Developments

DevFeed: [Other Driven Developments](<https://devfeed.tech/articles/other-driven-developments-1513.md>)

Original publisher: [Read original article](<https://shopify.engineering/other-driven-developments>)

Author: J D

Published: 2021-05-21T17:30:00Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [Code](<https://devfeed.tech/topics/code.md>), [Tech Lead](<https://devfeed.tech/topics/tech-lead.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>)

Tags: [career](<https://devfeed.tech/tags/career.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [mental-models](<https://devfeed.tech/tags/mental-models.md>), [models](<https://devfeed.tech/tags/models.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [tech-lead](<https://devfeed.tech/tags/tech-lead.md>)

### AI overview

This article discusses how development methodologies and mental models evolve as teams and companies grow. It introduces additional "driven development" approaches, including Grep Driven Development, and explains how explicit practices can turn implicit lessons into shared guidance. It also highlights how expressive Ruby variable names improve searchability, refactorability, abstraction, and consistency.

### Source excerpt

Mental models within an industry, company, or even a person, change constantly. As methodologies mature, we see the long term effects our choices have wrought and can adjust accordingly. As a team or company grows, methodologies that worked well for five people may not work as well for 40 people. If all employees could keep an entire app in their head, we'd need fewer rules and checks and balances on our development, but that is not the case. As a result, we summarize things we notice have been implicit in our work.

## Writing First-Class Features: BDD and Gherkin.

DevFeed: [Writing First-Class Features: BDD and Gherkin.](<https://devfeed.tech/articles/writing-first-class-features-bdd-and-gherkin-34670.md>)

Original publisher: [Read original article](<http://fernandocejas.com/blog/engineering/2021-01-23-writing-first-class-features-bdd-gherkin/>)

Author: Fernando Cejas (me@fernandocejas.com)

Published: 2021-01-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fernando Cejas Blog](<https://devfeed.tech/sources/fernando-cejas-blog.md>)

Topics: [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [domain-specific language](<https://devfeed.tech/topics/domain-specific-language.md>), [Development](<https://devfeed.tech/topics/development.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [bdd](<https://devfeed.tech/tags/bdd.md>), [communication](<https://devfeed.tech/tags/communication.md>), [culture](<https://devfeed.tech/tags/culture.md>), [development](<https://devfeed.tech/tags/development.md>), [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [feature](<https://devfeed.tech/tags/feature.md>), [framework](<https://devfeed.tech/tags/framework.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [ios](<https://devfeed.tech/tags/ios.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [linux](<https://devfeed.tech/tags/linux.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [organization](<https://devfeed.tech/tags/organization.md>), [processes](<https://devfeed.tech/tags/processes.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [rust](<https://devfeed.tech/tags/rust.md>), [scala](<https://devfeed.tech/tags/scala.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [web-development](<https://devfeed.tech/tags/web-development.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The article explains how behavior-driven development (BDD) and the Gherkin domain-specific language can establish a shared vocabulary for writing software features. It presents BDD as a collaborative process involving developers, QA, and business participants, and describes how structured natural-language scenarios can express behavior and acceptance criteria.

### Source excerpt

As our product evolves, **there is the need to adopt a common vocabulary**, interpreted by all the moving parts of our organization: business users, analysts, managers, engineers, etc. **A technique like BDD and the Gherkin language can help us to achieve this goal**.

## Automation-First Approach Using the Karate API Testing Framework

DevFeed: [Automation-First Approach Using the Karate API Testing Framework](<https://devfeed.tech/articles/automation-first-approach-using-the-karate-api-testing-framework-27978.md>)

Original publisher: [Read original article](<https://tech.trivago.com/post/2019-11-14-apitestautomationusingkarate/>)

Author: Anila Saifan Software Engineer QA; Test Automation enthusiast

Published: 2019-11-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [Trivago](<https://devfeed.tech/sources/trivago.md>)

Topics: [Automation](<https://devfeed.tech/topics/automation.md>), [API](<https://devfeed.tech/topics/api.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Framework](<https://devfeed.tech/topics/framework.md>), [Java](<https://devfeed.tech/topics/java.md>), [Maven](<https://devfeed.tech/topics/maven.md>), [Cucumber](<https://devfeed.tech/topics/cucumber.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [api-testing](<https://devfeed.tech/tags/api-testing.md>), [automation](<https://devfeed.tech/tags/automation.md>), [backend](<https://devfeed.tech/tags/backend.md>), [bdd](<https://devfeed.tech/tags/bdd.md>), [cli](<https://devfeed.tech/tags/cli.md>), [given-when-then](<https://devfeed.tech/tags/given-when-then.md>), [ide](<https://devfeed.tech/tags/ide.md>), [java](<https://devfeed.tech/tags/java.md>), [maven](<https://devfeed.tech/tags/maven.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [specflow](<https://devfeed.tech/tags/specflow.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This tutorial explains how to use Karate, an open-source API test automation tool, with behavior-driven development syntax. It covers project setup with Java and Maven, writing API tests, running them, and using custom functions.

### Source excerpt

Adopting an automation-first mindset is the first step to reduce manual and repetitive work. Thinking this way enables us to move faster, and more efficiently. It unburdens us from mundane, repe...

## Threat Modeling Tooling from 2017

DevFeed: [Threat Modeling Tooling from 2017](<https://devfeed.tech/articles/threat-modeling-tooling-from-2017-37051.md>)

Original publisher: [Read original article](<https://shostack.org/blog/threat-modeling-tooling-from-2017/>)

Author: Adam

Published: 2017-12-28T00:00:00Z

Content type: opinion

Language: en

Sources: [Shostack & Friends Blog](<https://devfeed.tech/sources/shostack-friends-blog.md>)

Topics: [Tooling](<https://devfeed.tech/topics/tooling.md>), [Application Security](<https://devfeed.tech/topics/application-security.md>), [Security](<https://devfeed.tech/topics/security.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Web](<https://devfeed.tech/topics/web.md>)

Tags: [application-security](<https://devfeed.tech/tags/application-security.md>), [bdd](<https://devfeed.tech/tags/bdd.md>), [cloud-security](<https://devfeed.tech/tags/cloud-security.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

A retrospective on threat-modeling tooling from 2017 highlights OWASP Threat Dragon, Tutamen, security-language initiatives, BDD-Security, and IriusRisk. The article emphasizes web-based collaboration, simple diagram-to-threat-list workflows, structured threat and control stories, and application security risk management.

### Source excerpt

[no description provided]

## Easy Approach to Requirements Syntax and the segue to Behavior Driven Development

DevFeed: [Easy Approach to Requirements Syntax and the segue to Behavior Driven Development](<https://devfeed.tech/articles/easy-approach-to-requirements-syntax-and-the-segue-to-behavior-driven-development-20778.md>)

Original publisher: [Read original article](<https://conductofcode.io/post/easy-approach-to-requirements-syntax-and-the-segue-to-behavior-driven-development/>)

Author: {"twitter"=\>"hlaueriksson"}

Published: 2017-07-31T20:00:00Z

Content type: article

Language: en

Sources: [Henrik Lau Eriksson](<https://devfeed.tech/sources/henrik-lau-eriksson.md>)

Topics: [Requirements](<https://devfeed.tech/topics/requirements.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>), [User Stories](<https://devfeed.tech/topics/user-stories.md>)

Tags: [bdd](<https://devfeed.tech/tags/bdd.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [event](<https://devfeed.tech/tags/event.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [format](<https://devfeed.tech/tags/format.md>), [precision](<https://devfeed.tech/tags/precision.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [simple](<https://devfeed.tech/tags/simple.md>), [specflow](<https://devfeed.tech/tags/specflow.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [state](<https://devfeed.tech/tags/state.md>), [test](<https://devfeed.tech/tags/test.md>), [user-stories](<https://devfeed.tech/tags/user-stories.md>)

### AI overview

The article introduces Easy Approach to Requirements Syntax (EARS) as a structured way to write requirements and examines how its templates may help translate user stories and acceptance criteria into Behavior-Driven Development tests. It describes five requirement types and the problems EARS aims to reduce, including ambiguity, vagueness, complexity, omission, duplication, wordiness, inappropriate implementation detail, and untestability.

### Source excerpt

I was attending a conference six months ago and listened to a talk about quality. During the talk, I was introduced to EARS -- Easy Approach to Requirements Syntax. This way of writing requirements struck a chord with me, given my prior experience reading and writing requirement specifications.

## Why Open Source Is Worth Your Time

DevFeed: [Why Open Source Is Worth Your Time](<https://devfeed.tech/articles/why-open-source-is-worth-your-time-33395.md>)

Original publisher: [Read original article](<https://timkellogg.me/blog/2012/04/22/why-open-source-is-worth-your-time>)

Published: 2012-04-22T00:00:00Z

Content type: opinion

Language: en

Sources: [Tim Kellogg](<https://devfeed.tech/sources/tim-kellogg.md>)

Topics: [Open Source](<https://devfeed.tech/topics/open-source.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [unit tests](<https://devfeed.tech/topics/unit-tests.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>)

Tags: [bdd](<https://devfeed.tech/tags/bdd.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [programming](<https://devfeed.tech/tags/programming.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The author argues that contributing to a relatively mainstream open-source project is an effective way to improve software engineering skills. By studying and participating in high-quality projects, developers can learn practices such as unit testing, maintainable design, behavior-driven development, deployment, support, and professional responses to criticism.

### Source excerpt

One of my math professors said that our beliefs are shaped by our life experiences. Two people can logically come to two very different lifestyle choices based on how they were raised, taught and friends that impacted them. The lecture was meant to apply to religious and moral beliefs, but I think it also applies to how we grow professionally.

## BDD ideas for structuring tests

DevFeed: [BDD ideas for structuring tests](<https://devfeed.tech/articles/bdd-ideas-for-structuring-tests-33387.md>)

Original publisher: [Read original article](<https://timkellogg.me/blog/2012/01/02/bdd-ideas-for-structuring-tests>)

Published: 2012-01-02T00:00:00Z

Content type: opinion

Language: en

Sources: [Tim Kellogg](<https://devfeed.tech/sources/tim-kellogg.md>)

Topics: [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [C#](<https://devfeed.tech/topics/csharp.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [unit tests](<https://devfeed.tech/topics/unit-tests.md>), [NUnit](<https://devfeed.tech/topics/nunit.md>), [Visual Studio](<https://devfeed.tech/topics/visual-studio.md>)

Tags: [bdd](<https://devfeed.tech/tags/bdd.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [nunit](<https://devfeed.tech/tags/nunit.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [unit-tests](<https://devfeed.tech/tags/unit-tests.md>), [visual-studio](<https://devfeed.tech/tags/visual-studio.md>)

### AI overview

The author discusses ways to structure behavior-driven development tests in C#. The article considers nested classes that organize tests by method, notes their compatibility with Visual Studio navigation, and compares that approach with namespace- and method-based setup practices.

### Source excerpt

Lately I've been thinking a lot about the best way to do BDD in C#. So when I saw Phil Haack's post about structuring unit tests, I think I had a joyful thought. Earlier I had been thinking in terms of using my Behavioral NUnit experimental project to hash out Haack's structuring idea with better BDD integration.In short, his idea is to use nested classes. There is the normal one-to-one class-to-test-class mapping, but each method under test gets it's own inner class. To use his example:In this example the Titleify and Knightify methods (imo two terrible uses of the -ify suffix) have corresponding test classes dedicating to testing only one method. Each method in the class (or Fact, in the case of xUnit. I actually haven't used xUnit but it seems to encourage a somewhat BDD readability) test one aspect of the method, much like the it method is used in rspec.I generally like Haack's test structure. For example, he points out how it plays nicely with Visual Studio's natural class/method navigation which makes the tests even more navigable. The only issue I have with it is that I dislike having 1000+ SLOC classes - tests or regular. If I were to adopt this method, I would probably break each of those inner classes into separate files (and use partial classes to break up the top class).My practice for a long time was to have one whole namespace per class under test. Consider my tests for objectflow. I actually picked up this practice from Garfield Moore, objectflow's original developer. Each class (or significant concept) has a namespace (e.g. objectflow.stateful.tests.unit.PossibleTransitions or PossibleTransitionTests). Each class in that namespace is names according to essentially what the Setup does. Some examples: WhenGivenOnlyBranches, WhenGivenOnlyYields, etc.I like the way these tests read. It's very easy to find a particular test or to read up on how a particular method is supposed to operate. But in practice this has led to very deep hierarchies, often with si

## Behavior Driven Development in C#

DevFeed: [Behavior Driven Development in C#](<https://devfeed.tech/articles/behavior-driven-development-in-c-33385.md>)

Original publisher: [Read original article](<https://timkellogg.me/blog/2011/12/28/behavior-driven-development-in-c>)

Published: 2011-12-28T00:00:00Z

Content type: opinion

Language: en

Sources: [Tim Kellogg](<https://devfeed.tech/sources/tim-kellogg.md>)

Topics: [Behavior-driven development](<https://devfeed.tech/topics/bdd.md>), [C#](<https://devfeed.tech/topics/csharp.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [NUnit](<https://devfeed.tech/topics/nunit.md>), [RSpec](<https://devfeed.tech/topics/rspec.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [bdd](<https://devfeed.tech/tags/bdd.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [nunit](<https://devfeed.tech/tags/nunit.md>), [rspec](<https://devfeed.tech/tags/rspec.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [testing](<https://devfeed.tech/tags/testing.md>), [unit-test](<https://devfeed.tech/tags/unit-test.md>), [unit-testing](<https://devfeed.tech/tags/unit-testing.md>)

### AI overview

The author explains why behavior-driven development became more manageable than conventional unit-test naming for complex code. They compare Ruby RSpec and .NET BDD approaches, and describe a simple BDD layer over NUnit to preserve its tooling and lower the barrier to contribution.

### Source excerpt

I've been a fan of Test Driven Development since I worked in an XP shop. But every time the work starts getting bigger and more complex I always struggle to not get lost in the magnitudes of tests. I remember many early-on conversations with my elders about unit test naming conventions. The [method]_[input]_[output] convention starts to break down badly when your inputs become things like mocks, or if there ends up being more than 1 or 2 inputs; same with outputs.When a coworker introduced me to BDD earlier this year, it really clicked and flowed naturally. The idea of writing tests so they read like sentences out of a book or spec seems like the answer to all my questions. The ruby rspec is beautiful:The organization of the tests forces you to focus on the expectations of your test and highlight descriptive assertions. This is especially useful for complicated setups with lots of mocks, etc. I put as much of my setup code in one of those before :each blocks, so that way the assertions are limited to simple inputs and one or two observations about the outputs.There's been a number of people in the .NET community that have attempted BDD but [imo] failed to grasp the simplicity. NBehave is a complete overhaul of unit testing that uses attributes like xUnit. As a result, NBehave doesn't really look at all like rspec - which really isn't a bad thing, necessarily. However, the thing I like about rspec is it's ability to describe things of arbitrary depth, which is handy when testing complex code:This spec is able to describe possible modes that the object under test can be in (complex inputs). This is made possible by rspec's arbitrary nesting depth. This is definitely a language feature that is much harder to implement in C#.My current approach to BDD in C# usually looks likeI think this is the simplest BDD layer I can slap on top of NUnit. And simple is important to me because (a) I do a lot of open source projects and I want to keep the barrier to entry for contributi