Behavior-Driven Development with Gherkin, Executable Examples, and AI-Assisted Automation
A practical, full-day hands-on training for Business Analysts, Product Owners, testers, and developers, where business and technical roles learn together. Learn how to turn refined requirements and concrete examples into clear test scenarios, executable tests, and living documentation.
Discover how GitHub Copilot and reusable Agent Skills reduce the repetitive effort of writing and reviewing test scenarios and accelerate test automation, making automated testing accessible and practical without replacing shared understanding, refinement, collaboration, or human review.
Course Overview
AI-Powered Behavior-Driven Development (BDD) is a full-day instructor-led workshop for teams that want requirements, tests, and documentation to describe the same expected behavior. Participants learn how to turn refined requirements and concrete examples into clear, business-readable test scenarios that support collaboration between Product Owners, Business Analysts, testers, and developers. These scenarios become executable specifications and living documentation, keeping the original business intent connected to testing and delivery.
Participants use reusable Agent Skills to apply BDD through a consistent, repeatable workflow instead of relying on isolated prompts. Teams create, maintain, and improve these skills as shared assets, so agreed scenario-writing standards, quality checks, and automation practices remain available and are applied consistently across the team. The skills guide GitHub Copilot through structured steps for creating, reviewing, and improving test scenarios, while incorporating shared standards, quality checks, and points for human review. AI reduces repetitive work and supports automation, but people remain responsible for shared understanding, business meaning, and approval of the final result.
Languages
You can attend a course in English, Croatian, Serbian or Bosnian.
Delivery Method
You can attend the course online (Live Virtual Class) or onsite (In Person).
The course is available as a public class, scheduled and open to a general audience, or a private class delivered internally for teams within a company.
Duration
The course takes a full day, approximately 8 hours, with half a day dedicated to hands-on labs.
Private deliveries can be adjusted to fit the organization's schedule.
Related Courses
If your team wants to strengthen its product backlog refinement practices using AI, the AI-Powered Backlog Management workshop helps them learn how to produce exactly the refined, example-rich work items that can be turned into executable specifications within this training. Additionally, Applying Professional Scrum (APS) and Applying Professional Scrum for Software Development (APS-SD) provide the teamwork foundation.
Course Description
AI-Powered Behavior-Driven Development (BDD) Training is an immersive full-day hands-on workshop for teams that want to move from separate requirements, test cases, and documentation toward shared, executable examples of expected behavior. BDD becomes most valuable when the same examples guide implementation, run as tests, and provide input for documentation. In this workshop, participants use GitHub Copilot and reusable Agent Skills to practice that flow, from refined requirements and business-readable scenarios to automated execution and generated documentation.
Many teams describe the same behavior several times: as requirements, acceptance criteria, manual test cases, automation code, and documentation. As delivery progresses, these artifacts can drift apart. Business intent is reinterpreted, automated tests use different language, and documentation becomes outdated. BDD addresses this problem by giving business and technical roles one shared set of concrete examples that can be discussed, reviewed, and executed.
AI can reduce the effort of creating scenarios and test automation, but isolated prompts do not provide a reliable team workflow. Reusable Agent Skills package prepared instructions, shared standards, quality checks, and review steps for a specific BDD activity. They guide GitHub Copilot through a repeatable sequence while keeping people responsible for business meaning and approval of the result.
In this workshop, you will experience practical skill-based workflow patterns such as:
- Turning a refined requirement and concrete examples into clear test scenarios,
- Creating and reviewing a Gherkin feature file that groups related scenarios in a business-readable form,
- Improving scenarios against shared quality standards before running them through automation,
- Running executable scenarios against a real application and interpreting the results,
- Seeing how AI can propose a missing step definition and, in the developer option, applying that workflow in .NET or Java, and
- Generating documentation from the executable scenarios and seeing how CI can keep published documentation aligned with them.
The automation work supports two levels of technical experience. Participants without programming experience combine prepared sentences that are already connected to automated tests. Developers can add new sentences and use AI to propose the missing step definitions, the test code that connects business-readable steps to the application, in .NET or Java. Both approaches use the same business rules, Gherkin format, and application, and demonstrate the same principle: a concrete business example can become an executable test.
You will see how GitHub Copilot, guided by reusable Agent Skills, can reduce repetitive scenario-writing and automation work while preserving shared understanding and human review. You will also see how requirements, executable tests, generated documentation, and work-item traceability can build on the same concrete examples.
No prior experience with BDD, Gherkin, or test automation tools is required. The option without programming requires no coding experience. Participants choosing the developer option should be comfortable reading and editing basic C# or Java.
Course Objectives
Understand how BDD uses shared, executable examples to connect requirements, tests, and documentation.
Turn refined requirements and concrete examples into clear, business-readable test scenarios.
Apply core Gherkin concepts — Feature, Scenario, Given/When/Then, and Scenario Outline — to structure expected behavior.
Use a reusable Agent Skill to follow a consistent workflow for creating, reviewing, and improving test scenarios.
Apply prepared standards, quality checks, and human review when evaluating AI-generated test scenarios.
Create and run automated scenarios using prepared, test-connected sentences and, in the developer option, use AI to add missing step definitions in .NET or Java.
Run executable specifications against an application and interpret results by comparing expected and observed behavior.
Generate documentation from executable scenarios and explain how CI feedback and work-item traceability build on them.
What You Will Learn
Participants work in a prepared, browser-based environment with a running application, GitHub Copilot, BDD tooling, and reusable Agent Skills. Guided by the instructor, they follow one requirement from refinement through scenario formulation, execution, automation, and generated documentation. Along the way, they see where human understanding, AI assistance, and test automation each belong.
The practical work follows the Discovery → Formulation → Automation flow and covers how to:
- Use refined requirements and concrete examples to identify expected behavior and structure clear Gherkin scenarios,
- Apply Feature, Scenario, Given/When/Then, and Scenario Outline while recognizing common Gherkin quality problems,
- Inspect a prepared Agent Skill, understand how its instructions, standards, and review steps guide GitHub Copilot, and use it to generate and review a feature file,
- Change data and compose executable scenarios from prepared, test-connected sentences without programming,
- Add a new business example and, in the developer option, use AI to generate and review one missing step definition in .NET or Java,
- Run scenarios against the application under test, execute a prepared browser-level scenario, and interpret failures in business terms, and
- Generate a local stakeholder-readable documentation snapshot and see how CI can regenerate and publish documentation from executable scenarios.
Participants leave with a shared model for using BDD across product, analysis, testing, and development: people agree on the behavior, AI accelerates formulation and automation, and executable examples connect testing with generated documentation.
Course Topics
Introduction to Behavior-Driven Development
The course introduces what BDD is, why it matters now, and how Discovery, Formulation, and Automation connect business, product, testing, and development around concrete examples.
From Refinement to Executable Specifications
Refinement, concrete examples, and shared understanding provide the foundation for writing good Gherkin. Clear and testable examples matter from the start because they help teams express expected behavior precisely and create scenarios that guide implementation and testing.
Gherkin Fundamentals & Quality
Feature, Scenario, Given, When, Then, and Scenario Outline provide a structure for describing expected behavior. Declarative style, one behavior per scenario, and concrete verified values make scenarios clearer and help avoid common mistakes.
Step Definitions and Test Automation
Readable scenario steps connect business examples to automation code. A prepared step vocabulary supports reuse of existing automation, execution against the application API, and a prepared browser scenario that runs against the application.
AI-Assisted BDD with GitHub Copilot and Agent Skills
Agent Skills guide GitHub Copilot through generating, reviewing, and improving feature files. AI checks existing automation and proposes only the missing step definitions. The developer option applies that workflow in .NET or Java. AI drafts the output, while people review its business meaning and developers review and own any generated code.
BDD in the Development and Testing Workflow
Generated documentation, CI feedback, business-readable test results, and work item traceability build on executable scenarios. A real delivery pipeline demonstrates the complete workflow.
Downloadable Course Description
Find further info about the course in PDF format at the following link: AI-Powered Behavior-Driven Development
Spend half the day applying BDD in guided labs, creating test scenarios, running automated tests, and generating documentation.
Who Should Attend
This training brings together people who shape requirements, define expected behavior, plan testing, build products, and support quality. Business and technical roles follow the same learning journey and work with the same business rules, Gherkin format, and application.
- Business Analysts and Requirements Engineers. Turn requirements and concrete examples into clear, testable Gherkin scenarios.
- Product Owners. Connect acceptance criteria and examples to executable specifications that guide development and testing.
- Testers and QA Specialists. Express expected behavior as Gherkin scenarios and run executable examples using prepared automation.
- People who plan or coordinate testing. Align testing activities around shared, business-readable, executable specifications.
- Scrum Masters and Agile Coaches. Support refinement and quality practices that lead to clear and testable BDD scenarios.
- Developers involved in test automation. Generate, review, and own step definitions in .NET or Java, while improving alignment between requirements, tests, and implementation.
Learning Paths
If BDD is new to you, start with Behavior-Driven Development, executable specifications that never go stale. The article introduces how concrete examples, Gherkin scenarios, automated tests, and living documentation work together. This workshop takes the next step by applying those ideas in a practical workflow with GitHub Copilot and reusable Agent Skills.
The AI-Powered Backlog Management workshop is a useful complementary starting point for teams that want to improve requirements, examples, and acceptance criteria before turning them into executable specifications. This BDD workshop continues that journey from refined backlog content into scenario formulation, automation, test execution, and generated documentation. It can also be taken independently.
If your team already uses Gherkin or test automation, this workshop helps answer the next question: how can AI reduce repetitive formulation and automation work without weakening shared understanding and human ownership?
The course uses GitHub Copilot and prepared .NET and Java examples, but the workflow applies more broadly wherever business-readable scenarios connect requirements, executable tests, and generated documentation.
Prerequisites
No prior experience with BDD, Gherkin, test automation tools, Agent Skills, or GitHub Copilot is required. Participants should have a basic understanding of how their team works with requirements, examples, and testing.
The option without programming requires no coding experience. Participants choosing the developer option should be comfortable reading and editing basic C# or Java. Prior experience with specific BDD frameworks is not required.
The lab environment is fully browser-based and prepared for participants, so no local installation or configuration is needed. GitHub Copilot access is provided as part of the workshop environment.
This is a hands-on course, so please have your own computer available.
How to Prepare
- New to BDD? Read our introduction, Behavior-Driven Development, executable specifications that never go stale, and the official Cucumber overview, Behaviour-Driven Development. They explain how concrete examples create shared understanding and move through Discovery, Formulation, and Automation.
- New to Gherkin? Skim the Gherkin Reference. Focus on Feature, Scenario, Given, When, Then, and Scenario Outline. These are the concepts used during the workshop.
- New to GitHub Copilot? Spend a few minutes with the GitHub Copilot Quickstart or the Prompt engineering for GitHub Copilot. Both help build a basic feel for clear instructions and reliable AI outputs.
- New to Agent Skills? Review Use Agent Skills in VS Code or the open standard at agentskills.io. They explain how reusable skills help AI assistants follow specific workflows more consistently.
- Think of one requirement from your own product and two or three concrete examples of how it should behave. You will use similar examples during the workshop to discuss expected behavior and test scenarios.
- No software installation is needed. The lab environment is fully web-based and will be provided on the day.
Public Classes
Public workshops are open to the general public and run when a minimum attendance threshold is met. Because participants come from different organizations, industries, and roles, the discussion covers a wide range of requirements, testing, and automation contexts. Attendees benefit from seeing how the same BDD patterns apply across different teams and projects.
No public dates are currently scheduled. Register your interest — new dates are announced once the minimum group size is reached, and registered participants are notified first.
Private Classes
Private delivery is the preferred option when an organization wants to align a team or multiple teams around the same approach to BDD and executable specifications. When participants work together regularly and attend together, they leave with shared vocabulary, shared scenario-writing standards, and a workflow they have already practiced.
The discussion and examples can be tailored to the organization's existing requirements, testing, and automation practices. Private classes are also useful when teams want to agree on how they will write and maintain Gherkin features before applying BDD more widely.
Bring business and technical roles together — and leave with a shared, executable language your team has already practiced.
What Is Included
Provisioned Lab Environment
Participants work in a prepared, browser-based GitHub Codespaces environment with GitHub Copilot, BDD tooling, and the application under test ready for the workshop.
Hands-on Guided Labs
Participants practice BDD and Gherkin foundations, Agent Skill orientation, AI-assisted formulation, executable scenarios, test automation, and generated documentation through four guided labs.
Reusable Agent Skills
Participants receive the Agent Skills used during the workshop, so they can review the workflow patterns and adapt the ideas after the training.
Materials and Resources
Participants receive post-class notes, useful links, and cheat sheets for Gherkin and the prepared step vocabulary.
Why is this Approach Relevant Now?
Modern delivery teams need requirements, tests, and documentation to reflect the same expected behavior. The current Cucumber BDD guidance emphasizes collaboration across roles, concrete examples, executable specifications, and documentation that is checked against system behavior.
At the same time, AI can reduce repetitive work in scenario formulation and test automation. GitHub's guide to writing tests with GitHub Copilot shows how Copilot can generate and improve tests, while also stressing that generated tests must be reviewed and extended where necessary.
The next step is moving from isolated prompts to repeatable workflows. GitHub's documentation explains how Agent Skills package instructions, scripts, and resources for specialized tasks. GitHub also recommends structured workflows with context, validation points, and human oversight when building reliable AI workflows.
This course brings these practices together. GitHub Copilot and reusable Agent Skills reduce repetitive scenario writing and automation work. BDD keeps concrete examples, shared understanding, executable tests, and generated documentation connected.
AI accelerates the workflow, while people remain responsible for business meaning, review, and engineering judgment.