Agent skill

Req To Test

by ArabelaTso in ArabelaTso/Skills-4-SE

Generates comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests, and end-to-end test cases.

Apache-2.0Auto-check passedTesting & QA

Install Req To Test

skills CLI
$ npx skills add ArabelaTso/Skills-4-SE --skill req-to-test -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install ArabelaTso/Skills-4-SE req-to-test --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/ArabelaTso/Skills-4-SE.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/req-to-test .claude/skills/req-to-test && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
req-to-test
GitHub stars
253
Token cost
~2.9k tokens
SKILL.md length
701 words
Files
4 (incl. references, assets)
Skills in repo
150
Repo updated
First seen
Licence
Apache-2.0

At a glance

Generates comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests, and end-to-end test cases.

  • Works in 6 steps: Analyze Requirements → Determine Test Types → Generate Test Scenarios → …
  • Converting requirements
  • SKILL.md covers Core Capabilities, Workflow, Best Practices and Common Patterns, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Req To Test is an agent skill from ArabelaTso/Skills-4-SE. 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, error cases, edge cases, and boundary conditions. Outputs structured test suites ready for implementation.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files and assets (for example `assets/test_suite_template.json`, `references/coverage_checklist.md` and `references/test_patterns.md`).

It sits in Testing & QA, covering Test generation, Integration testing and Unit testing. The repository describes itself as: A curated list of 180+ useful Claude Skills for Software Engineering and resources for customizing AI for SE workflows. The licence is Apache-2.0.

When your agent uses it

  • Converting requirements
  • Specifications into testable scenarios with full coverage including happy paths
  • Boundary conditions

Example prompts

  • “Use the req-to-test skill to generate comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests…”
  • “/req-to-test”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Analyze Requirements
  2. Determine Test Types
  3. Generate Test Scenarios
  4. Ensure Comprehensive Coverage
  5. Prioritize Test Scenarios
  6. Structure Output

What it can do on your machine

Read from SKILL.md and the folder at commit 4f38503. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are gherkin and markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Req To Test loads about 2.9k tokens when it runs, and up to ~7.1k if it reads all its reference files. Until then it costs about 100 tokens; SKILL.md has 701 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~100
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from ArabelaTso/Skills-4-SE at commit 4f38503, republished under its Apache-2.0 licence (© ArabelaTso). 701 words, ~2,896 tokens.

Download SKILL.mdSave it as .claude/skills/req-to-test/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
req-to-test
description
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, error cases, edge cases, and boundary conditions. Outputs structured test suites ready for implementation.

Requirement to Test Scenario Generation

You are an expert test engineer who transforms requirements into comprehensive, executable test scenarios.

Core Capabilities

This skill enables you to:

  1. Analyze requirements - Extract testable behaviors and conditions from requirements
  2. Generate BDD scenarios - Create Given-When-Then scenarios in Gherkin format
  3. Design unit tests - Generate function-level test cases with assertions
  4. Create integration tests - Design tests for system interactions and APIs
  5. Build E2E tests - Develop complete user journey test scenarios
  6. Ensure coverage - Generate happy path, error cases, edge cases, and boundaries
  7. Prioritize tests - Classify tests by criticality and risk

Workflow

Follow this process when generating test scenarios from requirements:

Step 1: Analyze Requirements

Read each requirement and identify:

  • Testable behaviors - What actions or outcomes can be verified?
  • Inputs and outputs - What data goes in and what should come out?
  • Preconditions - What must be true before the action?
  • Success criteria - What defines success?
  • Error conditions - What can go wrong?
  • Constraints - What limits or rules apply?
  • Dependencies - What other systems or components are involved?
Step 2: Determine Test Types

For each requirement, decide which test types are needed:

BDD/Gherkin Scenarios - Use for:

  • User-facing features
  • Business workflows
  • Acceptance criteria validation
  • Stakeholder communication

Unit Tests - Use for:

  • Individual functions/methods
  • Business logic validation
  • Algorithm correctness
  • Data transformations

Integration Tests - Use for:

  • API interactions
  • Database operations
  • Message queue handling
  • Service-to-service communication

E2E Tests - Use for:

  • Complete user journeys
  • Multi-step workflows
  • Cross-system processes
  • Critical business paths
Step 3: Generate Test Scenarios

For each test type, use the patterns in references/test_patterns.md:

A. BDD/Gherkin Scenarios

Structure scenarios as:

gherkin
Feature: User Registration
  As a new user
  I want to create an account
  So that I can access the platform

  Scenario: Successful registration with valid credentials
    Given I am on the registration page
    And I am not logged in
    When I enter email "user@example.com"
    And I enter password "SecurePass123"
    And I click "Register"
    Then I see "Registration successful"
    And I am redirected to the dashboard
    And a confirmation email is sent to "user@example.com"

  Scenario: Registration fails with invalid email
    Given I am on the registration page
    When I enter email "invalid-email"
    And I enter password "SecurePass123"
    And I click "Register"
    Then I see error "Please enter a valid email address"
    And I remain on the registration page
    And no account is created
B. Unit Test Cases

Generate test cases with clear structure:

Test Suite: User Registration Validation

Test: test_validate_email_accepts_valid_format
  Setup: None required
  Input: email = "user@example.com"
  Execute: result = validate_email(email)
  Assert: result == True

Test: test_validate_email_rejects_invalid_format
  Setup: None required
  Input: email = "invalid-email"
  Execute: result = validate_email(email)
  Assert: result == False

Test: test_validate_email_rejects_empty_string
  Setup: None required
  Input: email = ""
  Execute: result = validate_email(email)
  Assert: result == False

Test: test_create_user_with_valid_data
  Setup:
    - Initialize database connection
    - Clear users table
  Input:
    - email = "user@example.com"
    - password = "SecurePass123"
  Execute: user = create_user(email, password)
  Assert:
    - user.email == "user@example.com"
    - user.password is hashed
    - user.created_at is set
    - user.id is generated
  Cleanup: Delete test user
C. Integration Test Scenarios

Design integration tests:

Test: User Registration API Integration

Setup:
  - Start test server
  - Initialize test database
  - Configure email service mock

Steps:
  1. POST /api/register with valid credentials
  2. Verify API returns 201 Created
  3. Verify response contains user ID and token
  4. Query database for new user record
  5. Verify email service was called with correct parameters

Assertions:
  - API response status: 201
  - Response body contains: {id: <uuid>, token: <jwt>}
  - Database contains user with email "user@example.com"
  - User password is hashed (not plain text)
  - Email service called with subject "Welcome"
  - Confirmation link in email contains valid token

Cleanup:
  - Delete test user from database
  - Stop test server
D. E2E Test Scenarios

Create complete user journeys:

Test: Complete User Registration and Login Journey

Scenario: New user registers and logs in successfully

  Given browser opens application homepage
  And no user exists with email "newuser@example.com"

  When user clicks "Sign Up" button
  Then registration page is displayed

  When user enters email "newuser@example.com"
  And user enters password "SecurePass123"
  And user enters password confirmation "SecurePass123"
  And user clicks "Create Account"
  Then success message "Account created successfully" appears
  And user is redirected to dashboard at "/dashboard"
  And welcome message displays "Welcome, newuser@example.com"

  When user logs out
  Then user is redirected to homepage

  When user clicks "Sign In"
  And user enters email "newuser@example.com"
  And user enters password "SecurePass123"
  And user clicks "Log In"
  Then user is redirected to dashboard
  And session is active

Verification:
  - User account persists in database
  - User can access protected resources
  - Session cookie is set correctly
Step 4: Ensure Comprehensive Coverage

Use the references/coverage_checklist.md to verify coverage:

Happy Path Coverage:

  • Primary success scenarios
  • Expected user behaviors
  • Normal data ranges

Error Path Coverage:

  • Invalid inputs for each field
  • Missing required data
  • Type mismatches
  • Business rule violations

Edge Case Coverage:

  • Boundary values (min, max, min-1, max+1)
  • Empty collections
  • Null/undefined values
  • Special characters
  • Concurrent operations
  • Network failures
  • System errors

Example - Comprehensive coverage for "Age" field (must be 18-65):

Happy Path:
  - age = 25 (valid middle value)
  - age = 18 (minimum boundary)
  - age = 65 (maximum boundary)

Error Cases:
  - age = 17 (below minimum)
  - age = 66 (above maximum)
  - age = -5 (negative)
  - age = 0 (zero)
  - age = "twenty" (invalid type)
  - age = null (missing)
  - age = "" (empty string)
  - age = 999999 (extremely large)

Edge Cases:
  - age = 17.9 (decimal below minimum)
  - age = 18.0 (decimal at minimum)
  - age = 65.1 (decimal above maximum)
Step 5: Prioritize Test Scenarios

Classify each test by priority:

Critical (P0):

  • Core business functionality
  • Payment/transaction flows
  • Security features (auth, permissions)
  • Data integrity operations
  • Regulatory compliance scenarios

High (P1):

  • Frequently used features
  • Error handling for common issues
  • Major user workflows
  • Integration points

Medium (P2):

  • Less common features
  • Alternative workflows
  • Nice-to-have validations
  • Edge cases for stable features

Low (P3):

  • Rarely used features
  • Minor UI variations
  • Cosmetic validations
Show full SKILL.md (283 more words)Show less
Step 6: Structure Output

Organize test scenarios clearly:

markdown
# Test Suite: [Feature Name]

## Overview
- Source Requirements: REQ-001, REQ-002
- Total Scenarios: 15
- Coverage: Happy path, Error cases, Edge cases

## BDD Scenarios

### Critical Priority

Feature: User Authentication
  Scenario: Successful login with valid credentials [P0]
  Scenario: Login fails with incorrect password [P0]

### High Priority

Feature: User Authentication
  Scenario: Login fails with non-existent user [P1]
  Scenario: Account locks after 5 failed attempts [P1]

## Unit Tests

### Module: auth.validators

Test: test_validate_password_strength_accepts_strong_password [P1]
Test: test_validate_password_strength_rejects_weak_password [P1]
Test: test_validate_password_strength_requires_minimum_length [P1]

## Integration Tests

Test: Authentication API returns JWT token on successful login [P0]
Test: Authentication API rate limits after repeated failures [P1]

## E2E Tests

Test: User can register, login, and access protected resources [P0]
Test: User session expires after timeout [P1]

## Test Data

Valid Credentials:
  - email: "valid.user@example.com"
  - password: "SecurePass123!"

Invalid Credentials:
  - email: "invalid@example.com" (non-existent)
  - password: "wrong" (incorrect)

## Coverage Summary

- Requirements Covered: 5/5 (100%)
- Happy Path: 5 scenarios
- Error Cases: 8 scenarios
- Edge Cases: 7 scenarios
- Total: 20 test scenarios

Best Practices

  1. One scenario, one behavior - Each test should verify a single behavior
  2. Use descriptive names - Test names should clearly state what is being tested
  3. Include context - Given clauses should set up complete context
  4. Be specific - Use concrete values, not vague descriptions
  5. Test negatives - Don't just test that things work, test that invalid things fail correctly
  6. Consider sequences - Test state transitions and workflows, not just isolated actions
  7. Think like an attacker - Include security test cases (injection, XSS, etc.)
  8. Verify side effects - Check that operations have expected side effects (logs, notifications, etc.)
  9. Make tests independent - Each test should work regardless of execution order
  10. Include cleanup - Ensure tests clean up after themselves

Common Patterns

Requirement Type → Test Approach

"User must be able to..." → BDD scenario + E2E test "System shall validate..." → Unit test for validator + BDD for user feedback "Data must be..." → Unit test for data constraint + Integration test for persistence "API endpoint..." → Integration test for API contract "When X happens, Y should..." → BDD scenario for behavior + Unit test for logic

Coverage Rules of Thumb

For each requirement, generate:

  • Minimum: 1 happy path + 1 error case
  • Good: Happy path + 3-5 error cases + 2-3 edge cases
  • Comprehensive: Happy path + all error conditions + boundary values + security cases

Output Formats

Provide test scenarios in requested format:

Gherkin/BDD - For human-readable acceptance tests JSON - For test automation frameworks (use assets/test_suite_template.json) Markdown - For documentation and review Code snippets - For specific testing frameworks (Jest, PyTest, etc.)

When format not specified, provide Markdown with all test types included.

Resources

  • references/test_patterns.md - Detailed patterns for each test type
  • references/coverage_checklist.md - Comprehensive coverage checklist
  • assets/test_suite_template.json - JSON template for structured output

© ArabelaTso, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references, assets) in skills/req-to-test of ArabelaTso/Skills-4-SE.

  • SKILL.md
  • assets/test_suite_template.json
  • references/coverage_checklist.md
  • references/test_patterns.md

Open the folder on GitHubat commit 4f38503

Compare with similar skills

Req To Test next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Req To Test compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Req To Test this skillArabelaTso/Skills-4-SE253—~2.9kAutomated safety check: PassApache-2.0
Atmos Testscloudposse/atmos1.4k—~1.9kAutomated safety check: PassApache-2.0
Memstack Development Test Writercwinvestments/memstack423—~3.7kAutomated safety check: PassProprietary
Frappe Testing UnitImpertio-Studio/Frappe_Claude_Skill_Package187—~3kAutomated safety check: PassMIT
Testing Safe Protocolarchibate/dotfiles-opencode108—~3.2kAutomated safety check: NotesNone
Test Experteinverne/dotfiles121—~2.3kAutomated safety check: PassGPL-3.0

Similar skills

  • Atmos Tests

    cloudposse/atmos

    Author Atmos smoke tests, post-deployment stack checks, and integration tests using type: test, HTTP assertions, shell or script/interpreter checks, require gates, parallel dependencies, matrix…

    1.4k GitHub stars~1.9k tokensUpdated yesterday
    Testing & QAAuto-check passed
  • Memstack Development Test Writer

    cwinvestments/memstack

    A skill your agent uses when the user says 'write tests', 'add tests', 'test coverage', 'unit tests', 'integration tests', 'component tests', 'mocking', 'edge cases', or needs to generate tests with…

    423 GitHub stars~3.7k tokensUpdated 12 days ago
    Testing & QAAuto-check passed
  • Frappe Testing Unit

    Impertio-Studio/Frappe_Claude_Skill_Package

    A skill your agent uses when writing unit tests, integration tests, creating test fixtures, or running tests with bench run-tests.

    187 GitHub stars~3k tokensUpdated 21 days ago
    Testing & QAAuto-check passed
  • Testing Safe Protocol

    archibate/dotfiles-opencode

    Safe testing practices to prevent real-world side-effects. An agent skill from archibate/dotfiles-opencode.

    108 GitHub stars~3.2k tokensUpdated 5 mo ago
    Testing & QAAuto-check: notes
  • Test Expert

    einverne/dotfiles

    Testing methodologies, test-driven development (TDD), unit and integration testing, and testing best practices across multiple frameworks.

    121 GitHub stars~2.3k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Scenario Testing

    aiskillstore/marketplace

    This skill should be used when writing tests, validating features, or needing to verify code works.

    430 GitHub starsUsed in 1 repo~830 tokens
    Testing & QAAuto-check passed

More from ArabelaTso/Skills-4-SE

All 150 skills in this repo
  • Framework Migration Assistant

    ArabelaTso/Skills-4-SE

    Automatically migrate Python web applications between frameworks (Flask → FastAPI, Django → FastAPI).

    253 GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check passed
  • Metamorphic Test Generator

    ArabelaTso/Skills-4-SE

    Generate test cases using metamorphic testing by applying transformations based on metamorphic properties.

    253 GitHub stars~798 tokensUpdated 1 mo ago
    Auto-check passed
  • Reproduction Trace Instrumenter

    ArabelaTso/Skills-4-SE

    Instruments programs to capture execution traces specifically for reproducing reported bugs, enabling consistent replay and diagnosis of failures.

    253 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed
  • Spring Mvc To Boot Migrator

    ArabelaTso/Skills-4-SE

    Automatically migrate Spring MVC applications to Spring Boot.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed
  • State Snapshot Instrumenter

    ArabelaTso/Skills-4-SE

    Instrument programs (Python, C/C++, Java) to capture snapshots of key program states at runtime, including variables, memory, and call stacks.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Req To Test

What does Req To Test do?

Generates comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests, and end-to-end test cases. Req To Test is an agent skill from ArabelaTso/Skills-4-SE. Generates comprehensive test scenarios from requirements including BDD/Gherkin scenarios, unit tests, integration tests, and end-to-end test cases.

When should I use Req To Test?

Req To Test fits situations like: converting requirements; specifications into testable scenarios with full coverage including happy paths; boundary conditions.

How do I install Req To Test in Claude Code?

Run `npx skills add ArabelaTso/Skills-4-SE --skill req-to-test -a claude-code`. Or copy the skill folder (skills/req-to-test in ArabelaTso/Skills-4-SE) into .claude/skills/req-to-test in your project. Claude Code loads it when a task matches its description.

How do I install Req To Test in Codex?

Run `npx skills add ArabelaTso/Skills-4-SE --skill req-to-test -a codex`. Or copy the skill folder (skills/req-to-test in ArabelaTso/Skills-4-SE) into .agents/skills/req-to-test in your project. Codex loads it when a task matches its description.

Can I use Req To Test in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ArabelaTso/Skills-4-SE --skill req-to-test -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/req-to-test, .gemini/skills/req-to-test, .github/skills/req-to-test and .opencode/skills/req-to-test in your project.

What does Req To Test need to run?

SKILL.md names no scripts, command-line tools or credentials: Req To Test is instructions for the agent only.

Does Req To Test access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Req To Test safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Req To Test use?

Req To Test is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Req To Test use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.2k tokens, read only when the agent opens those files.

What are the alternatives to Req To Test?

Skills that share tags, products or a category with Req To Test: Atmos Tests (cloudposse/atmos, 1.4k stars), Memstack Development Test Writer (cwinvestments/memstack, 423 stars), Frappe Testing Unit (Impertio-Studio/Frappe_Claude_Skill_Package, 187 stars) and Testing Safe Protocol (archibate/dotfiles-opencode, 108 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Req To Test?

ArabelaTso (a GitHub user) maintains it in ArabelaTso/Skills-4-SE, which has 253 GitHub stars. The repository holds 150 skills in this directory. The repository was last updated on August 21, 2026.

Source: ArabelaTso/Skills-4-SE on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.