Skip to content
Skills Library
Programming · Writing

bdd-formulation

/bdd-formulation

Use when writing or reviewing Gherkin scenarios, especially after discovering examples or edge cases that reveal a business rule

Repository
yaks ↗
Licence
MIT
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when writing or reviewing Gherkin scenarios, especially after discovering examples or edge cases that reveal a business rule

Original author description

Use when writing or reviewing Gherkin scenarios, especially after discovering examples or edge cases that reveal a business rule

How it works

  1. Core Habit
  2. BRIEF Check
  3. Guidelines
  4. Review Questions
Original SKILL.md headings · 51 lines, 310 words
SKILL.md preview
---
name: bdd-formulation
description: Use when writing or reviewing Gherkin scenarios, especially after discovering examples or edge cases that reveal a business rule
---

# BDD Formulation

Formulation is the craft of writing Gherkin that serves as
living documentation. Good scenarios are concrete examples
of business rules, not test scripts.

## Core Habit

When examples reveal a rule, make the rule visible in the
feature file: group related scenarios under a `Rule:` keyword
that states the rule they illustrate.

```gherkin
Rule: Manual blockers replace the existing manual blocker

  Scenario: Adding another manual blocker updates the reason
    Given I add the yak "deploy"
    And I add manual blocker to "deploy" with reason "waiting on vendor"
    When I add manual blocker to "deploy" with reason "waiting on review"
    Then the JSON yak "deploy" should have exactly one manual blocker with reason "waiting on review"
```

## BRIEF Check

From Seb Rose, scenarios should be:

- **B**usiness language: terms stakeholders understand.
- **R**eal data: vivid, concrete examples.
- **I**ntention revealing: say what matters, not how the UI works.
- **E**ssential: every line serves the rule.
- **F**ocused: one rule per scenario, short enough to read.

## Guidelines

- Use `Rule:` for a business/domain rule, not an implementation mechanism.
- Keep scenario names as concrete examples of the rule, not restatements of it.
- If a scenario discovers a new rule, add or split out a new `Rule:` section.
- If a scenario appears to illustrate multiple rules, split it.
- Prefer several small `Rule:` groups over one long pile of loosely related scenarios.
- Carry one consistent narrative through a feature where possible.
- Put cross-cutting assertions, such as output or logging, on existing scenarios rather than in separate rules.

## Review Questions

- What rule does this scenario prove?
- Does the Example name add information beyond the Rule?
- Is every line essential?
- Is the data concrete and business-readable?
- Would a feature with no `Rule:` sections be clearer if its rules were extracted?

Versions

The database has no other skills named bdd-formulation.

Database snapshot: 13.11.2026 · package version 6ea85ca2d15e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100bdd
    Behavior-driven development: Discovery → Formulation → Automation. Use when the user wants to build features or fix bugs via Gherkin scenarios and the BDD lifecycle, or mentions BDD/Gherkin/Executable Specifications. Delegates test implementation to /mattpocock:tdd.
  • 100behavior-driven-development-bdd-cucumber
    Use this skill when bridging technical implementations and business requirements using Gherkin Given-When-Then scenarios.
  • 100bdd-methodology
    Use when writing, reviewing, or structuring BDD scenarios in Gherkin format. Covers Given/When/Then conventions, scenario outline patterns, background usage, tag strategies, and domain language alignment. Load before any Gherkin authoring.
  • 100gherkin-scenarios
    Write clean, business-readable Gherkin (Given/When/Then) scenarios and scenario outlines from acceptance criteria or examples, then lint them with a bundled script (one When per scenario, no UI clicks in steps, no vague words). Use for BDD, Cucumber/SpecFlow/Reqnroll/behave…
  • 100pwauto-scenarios
    Designs risk-based BDD scenarios in Gherkin from the knowledge base: declarative steps, happy, negative, boundary and role cases, tags, data tables and a traceability table. Writes them as @draft feature files for review. Use when the user says 'write test cases', 'write…
  • 100req-to-test
    Generates comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests, and end-to-end test cases. Use when converting requirements, user stories, or specifications into testable scenarios with full coverage including happy paths,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.