Skip to main content
skill CX Codex

cucumber-skill — Claude Code skill: Cucumber tests and installation

Creates Gherkin feature files and matching step definitions. Use it to turn application behavior into Cucumber BDD scenarios.

MIT 283 installs ★ 393 updated 2026-10-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add LambdaTest/agent-skills --skill cucumber-skill -a claude-code
Open on GitHub

What cucumber-skill does

The skill helps write Gherkin features with Background, Scenario, and Examples, then connect their steps to Java, JavaScript, or Ruby code. Its examples cover login checks, hooks for scenario setup and teardown, and tags for selecting which tests to run.

Java and JavaScript examples also show cloud execution on TestMu AI. That setup needs the LT_USERNAME and LT_ACCESS_KEY environment variables. The local run command depends on the language: Java uses mvn test, while JavaScript uses npx cucumber-js. The cloud example cannot authenticate without those environment variables.

What it helps with

  • write application behavior as Gherkin scenarios
  • connect Given/When/Then steps to Java or JavaScript
  • filter test runs with tags
  • capture a screenshot when a scenario fails

Example prompts for the agent

  • Write Gherkin scenarios for user login and add Java step definitions.
  • Turn these UI steps into a Cucumber business scenario with Background and Scenario Outline.
  • Add Cucumber hooks that attach a screenshot when a scenario fails.

How to install cucumber-skill

1Skills CLI (Vercel)

npx skills add LambdaTest/agent-skills --skill cucumber-skill -a claude-code

2Manually: put the files in place

~/.claude/skills/cucumber-skill/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cucumber-skill/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cucumber-skill

How do I install cucumber-skill in Claude Code?

Run npx skills add LambdaTest/agent-skills --skill cucumber-skill -a claude-code. The skill file is placed at ~/.claude/skills/cucumber-skill/SKILL.md.

What does cucumber-skill do?

It helps create Gherkin scenarios and connect them to step definitions in Java, JavaScript, or Ruby. It also includes examples of hooks and tag-based test runs.

Which environment variables does the TestMu AI cloud example need?

Set LT_USERNAME and LT_ACCESS_KEY in the environment. The cloud execution examples are for Java and JavaScript.

Source text

SKILL.md · MIT
---
name: cucumber-skill
description: >
  Generates Cucumber BDD tests with Gherkin feature files and step definitions
  in Java, JavaScript, or Ruby. Use when user mentions "Cucumber", "Gherkin",
  "Feature/Scenario", "Given/When/Then", "BDD". Triggers on: "Cucumber",
  "Gherkin", "BDD", "Feature file", "Given/When/Then", "step definitions".
languages:
  - Java
  - JavaScript
  - Ruby
  - TypeScript
category: bdd-testing
license: MIT
metadata:
  author: TestMu AI
  version: "1.0"
---

# Cucumber BDD Skill

## Core Patterns

### Feature File (Gherkin)

```gherkin
Feature: User Login
  As a registered user
  I want to log into the application
  So that I can access my dashboard

  Background:
    Given I am on the login page

  Scenario: Successful login
    When I enter "[email protected]" in the email field
    And I enter "password123" in the password field
    And I click the login button
    Then I should be redirected to the dashboard
    And I should see "Welcome" on the page

  Scenario: Invalid credentials
    When I enter "[email protected]" in the email field
    And I enter "wrongpass" in the password field
    And I click the login button
    Then I should see an error message "Invalid credentials"

  Scenario Outline: Login with various users
    When I enter "<email>" in the email field
    And I enter "<password>" in the password field
    And I click the login button
    Then I should see "<result>"

    Examples:
      | email           | password    | result     |
      | [email protected]  | admin123    | Dashboard  |
      | [email protected]   | password    | Dashboard  |
      | [email protected]    | wrong       | Error      |
```

### Step Definitions — Java

```java
import io.cucumber.java.en.*;
import static org.junit.jupiter.api.Assertions.*;

public class LoginSteps {
    private LoginPage loginPage;
    private DashboardPage dashboardPage;

    @Given("I am on the login page")
    public void iAmOnTheLoginPage() {
        loginPage = new LoginPage(driver);
        loginPage.navigate();
    }

    @When("I enter {string} in the email field")
    public void iEnterEmail(String email) {
        loginPage.enterEmail(email);
    }

    @When("I enter {string} in the password field")
    public void iEnterPassword(String password) {
        loginPage.enterPassword(password);
    }

    @When("I click the login button")
    public void iClickLogin() {
        dashboardPage = loginPage.clickLogin();
    }

    @Then("I should be redirected to the dashboard")
    public void iShouldBeOnDashboard() {
        assertTrue(driver.getCurrentUrl().contains("/dashboard"));
    }

    @Then("I should see {string} on the page")
    public void iShouldSeeText(String text) {
        assertTrue(dashboardPage.getPageSource().contains(text));
    }
}
```

### Step Definitions — JavaScript

```javascript
const { Given, When, Then } = require('@cucumber/cucumber');
const { expect } = require('chai');

Given('I am on the login page', async function() {
  await this.page.goto('/login');
});

When('I enter {string} in the email field', async function(email) {
  await this.page.fill('#email', email);
});

When('I click the login button', async function() {
  await this.page.click('button[type="submit"]');
});

Then('I should see {string} on the page', async function(text) {
  const content = await this.page.textContent('body');
  expect(content).to.include(text);
});
```

### Hooks

```java
import io.cucumber.java.*;

public class Hooks {
    @Before
    public void setUp(Scenario scenario) {
        driver = new ChromeDriver();
    }

    @After
    public void tearDown(Scenario scenario) {
        if (scenario.isFailed()) {
            byte[] screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES);
            scenario.attach(screenshot, "image/png", "failure-screenshot");
        }
        driver.quit();
    }
}
```

### Tags

```gherkin
@smoke
Feature: Login
  @critical @fast
  Scenario: Quick login
    ...

  @slow @regression
  Scenario: Full login flow
    ...
```

```bash
# Run by tag
mvn test -Dcucumber.filter.tags="@smoke"
mvn test -Dcucumber.filter.tags="@smoke and not @slow"
```

### Anti-Patterns

| Bad | Good | Why |
|-----|------|-----|
| UI details in Gherkin | Business language | Readability |
| One step per line of code | Meaningful business steps | Abstraction |
| No Background for shared steps | Use Background | DRY |
| Imperative steps | Declarative steps | Maintainable |


### Cloud Execution on TestMu AI

Set environment variables: `LT_USERNAME`, `LT_ACCESS_KEY`

**Java:**
```java
// CucumberHooks.java
ChromeOptions browserOptions = new ChromeOptions();
HashMap<String, Object> ltOptions = new HashMap<>();
ltOptions.put("user", System.getenv("LT_USERNAME"));
ltOptions.put("accessKey", System.getenv("LT_ACCESS_KEY"));
ltOptions.put("build", "Cucumber Build");
ltOptions.put("name", scenario.getName());
ltOptions.put("platformName", "Windows 11");
ltOptions.put("video", true);
browserOptions.setCapability("LT:Options", ltOptions);
driver = new RemoteWebDriver(new URL("https://hub.lambdatest.com/wd/hub"), browserOptions);
```

**JavaScript:**
```javascript
const driver = new Builder()
  .usingServer(`https://${process.env.LT_USERNAME}:${process.env.LT_ACCESS_KEY}@hub.lambdatest.com/wd/hub`)
  .withCapabilities({ browserName: 'chrome', 'LT:Options': {
    user: process.env.LT_USERNAME, accessKey: process.env.LT_ACCESS_KEY,
    build: 'Cucumber Build', platformName: 'Windows 11', video: true
  }}).build();
```
## Quick Reference

| Task | Command |
|------|---------|
| Run all (Java) | `mvn test` with cucumber-junit-platform-engine |
| Run all (JS) | `npx cucumber-js` |
| Run tagged | `--tags "@smoke"` |
| Dry run | `--dry-run` |
| Generate snippets | Run undefined steps |

## Deep Patterns → `reference/playbook.md`

| § | Section | Lines |
|---|---------|-------|
| 1 | Project Setup & Configuration | Maven, runner, rerun |
| 2 | Feature Writing Patterns | Background, outlines, DataTable |
| 3 | Step Definitions | Typed steps, DI injection |
| 4 | Dependency Injection & Shared State | PicoContainer, ScenarioContext |
| 5 | Hooks (Lifecycle Management) | Before/After ordering, screenshots |
| 6 | Custom Parameter Types | Transformers, DocString |
| 7 | Parallel Execution | Thread-safe, TestNG parallel |
| 8 | Reporting | Allure, masterthought, JSON |
| 9 | CI/CD Integration | GitHub Actions, tag matrix |
| 10 | Debugging Quick-Reference | 10 common problems |
| 11 | Best Practices Checklist | 13 items |

© TestMu AI · MIT · LambdaTest/agent-skills

Similar skills

All skills for Testing and QA →

From the same set47

The whole set →
jest-skill Produces Jest unit and integration tests across JavaScript and TypeScript, covering mocks, snapshots, and React components. CX Codex +1 292installs cicd-pipeline-skill cicd-pipeline-skill generates CI/CD configs for test automation: GitHub Actions, Jenkins, GitLab CI, Azure DevOps. Includes TestMu AI cloud integration. CX Codex +1 290installs junit-5-skill Generates production-grade JUnit 5 unit tests for Java with assertions, parameterized tests, Mockito mocks, and nested test groups. Use it to quickly cover your Java code with tests. CX Codex +1 289installs phpunit-skill This skill generates PHPUnit tests for PHP code, including assertions, data providers, mocks, and test doubles. Use it when you need tests shaped around a class or service. CX Codex +1 287installs webdriverio-skill Generates WebdriverIO end-to-end tests in JavaScript or TypeScript for local runs and TestMu AI cloud. CX Codex +1 265installs cypress-skill Generates production-grade E2E and component tests in JavaScript or TypeScript. Runs tests locally or on TestMu AI cloud, understands Cypress commands, and writes tests with proper selectors and network interception. CX Codex +1 264installs robot-framework-skill robot-framework-skill turns a described scenario into a .robot test in keyword-driven syntax, with SeleniumLibrary for browser flows and RequestsLibrary for API checks. CX Codex +1 253installs detox-skill Generates Detox E2E tests for React Native projects in JavaScript and TypeScript. Sets up tests for local emulators and TestMu AI cloud runs. CX Codex +1 252installs

Project sponsors

Companies that keep this analytics open