Skip to main content
skill CX Codex

qe-requirements-validation — Claude Code skill: validate requirements

qe-requirements-validation is a skill that checks acceptance criteria for testability, links requirements to test cases, and generates BDD scenarios from user stories before development.

MIT 141 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill qe-requirements-validation -a claude-code
Open on GitHub

What qe-requirements-validation does

The skill operates at multiple levels: it parses acceptance criteria directly from Jira, builds a traceability matrix connecting user stories to tests, and generates Gherkin scenarios for each story. Built-in checks use the SMART methodology (Specific, Measurable, Achievable, Relevant, Testable) to flag ambiguities and missing edge cases, then identifies untested requirements.

The traceability matrix shows which tests cover each requirement, detects orphan tests without linked requirements, and calculates coverage percentage. The BDD generator creates feature files with happy paths, edge cases, and error scenarios, optionally producing step definition stubs.

The skill works with multiple sources: Jira projects, local requirement and test files, and Markdown documentation. It needs access to test code and implementation to build a complete traceability picture.

What it helps with

  • validate acceptance criteria for testability before a sprint
  • build a traceability matrix linking requirements to test cases
  • generate BDD scenarios from user stories in Gherkin format
  • identify untested requirements and orphan tests
  • assess whether requirements coverage is adequate

Example prompts for the agent

  • Check the acceptance criteria for story US-123 against SMART principles
  • Build a traceability matrix for the current sprint and show coverage gaps
  • Generate Gherkin scenarios for the user registration feature

How to install qe-requirements-validation

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill qe-requirements-validation -a claude-code

2Manually: put the files in place

~/.claude/skills/qe-requirements-validation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/qe-requirements-validation/

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

Questions about qe-requirements-validation

How do I install qe-requirements-validation in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill qe-requirements-validation -a claude-code, then open ~/.claude/skills/qe-requirements-validation/SKILL.md to verify the setup.

What does qe-requirements-validation do?

It validates acceptance criteria using SMART methodology and checks for testability; builds a traceability matrix between requirements and test cases; generates Gherkin BDD scenarios; identifies untested requirements and coverage gaps.

Which sources of requirements does it support?

The skill integrates with Jira projects (fetches stories and criteria), local requirement and test files, and Markdown documentation. To build a complete traceability matrix, it needs access to your test code and implementation.

Source text

SKILL.md · MIT
---
name: "qe-requirements-validation"
description: "Validates acceptance criteria for testability, traces requirements to test cases, and generates BDD scenarios from user stories. Use when validating acceptance criteria, building requirements traceability matrices, managing Gherkin scenarios, or ensuring complete requirements coverage before development."
trust_tier: 3
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
  eval_path: evals/qe-requirements-validation.yaml
---

# QE Requirements Validation

## Purpose

Guide the use of v3's requirements validation capabilities including acceptance criteria parsing, requirements traceability, BDD scenario generation, and coverage gap identification.

## Activation

- When validating requirements
- When tracing requirements to tests
- When generating BDD scenarios
- When assessing requirements coverage
- When reviewing acceptance criteria

## Quick Start

```bash
# Parse acceptance criteria
aqe requirements parse --source jira --project MYAPP

# Build traceability matrix
aqe requirements trace --requirements reqs/ --tests tests/

# Generate BDD scenarios
aqe requirements bdd --story US-123 --output features/

# Check requirements coverage
aqe requirements coverage --sprint current
```

## Agent Workflow

```typescript
// Requirements validation
Task("Validate acceptance criteria", `
  Review acceptance criteria for sprint stories:
  - Check SMART criteria (Specific, Measurable, Achievable, Relevant, Testable)
  - Identify ambiguous requirements
  - Flag missing edge cases
  - Suggest improvements
`, "qe-acceptance-criteria")

// Traceability matrix
Task("Build traceability", `
  Create requirements traceability matrix:
  - Map user stories to test cases
  - Identify untested requirements
  - Find orphan tests (no linked requirement)
  - Calculate coverage metrics
`, "qe-traceability-builder")
```

## Requirements Operations

### 1. Acceptance Criteria Validation

```typescript
await acceptanceCriteria.validate({
  source: {
    type: 'jira',
    project: 'MYAPP',
    stories: 'sprint=current'
  },
  validation: {
    specific: true,
    measurable: true,
    achievable: true,
    relevant: true,
    testable: true
  },
  output: {
    score: true,
    issues: true,
    suggestions: true
  }
});
```

### 2. Traceability Matrix

```typescript
await traceabilityBuilder.build({
  requirements: {
    source: 'jira',
    types: ['story', 'task', 'bug']
  },
  artifacts: {
    tests: 'tests/**/*.test.ts',
    code: 'src/**/*.ts',
    documentation: 'docs/**/*.md'
  },
  output: {
    matrix: true,
    coverage: true,
    gaps: true,
    orphans: true
  }
});
```

### 3. BDD Scenario Generation

```typescript
await bddGenerator.generate({
  requirements: userStory,
  format: 'gherkin',
  scenarios: {
    happyPath: true,
    edgeCases: true,
    errorCases: true,
    dataVariations: true
  },
  output: {
    featureFile: true,
    stepDefinitions: 'skeleton'
  }
});
```

### 4. Coverage Analysis

```typescript
await requirementsCoverage.analyze({
  scope: 'sprint-23',
  metrics: {
    requirementsCovered: true,
    testCasesCoverage: true,
    automationCoverage: true,
    riskAssessment: true
  },
  report: {
    summary: true,
    details: true,
    recommendations: true
  }
});
```

## Traceability Matrix

```typescript
interface TraceabilityMatrix {
  requirements: {
    id: string;
    title: string;
    type: string;
    priority: string;
    status: string;
    linkedTests: string[];
    linkedCode: string[];
    coverage: 'full' | 'partial' | 'none';
  }[];
  tests: {
    id: string;
    name: string;
    type: 'unit' | 'integration' | 'e2e';
    linkedRequirements: string[];
    automated: boolean;
  }[];
  coverage: {
    requirementsCovered: number;
    requirementsPartial: number;
    requirementsUncovered: number;
    orphanTests: number;
  };
  gaps: {
    requirement: string;
    missingCoverage: string[];
    risk: 'high' | 'medium' | 'low';
  }[];
}
```

## BDD Integration

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

  @happy-path
  Scenario: Successful registration with valid details
    Given I am on the registration page
    When I enter valid email "[email protected]"
    And I enter valid password "SecurePass123!"
    And I click the register button
    Then I should see a success message
    And I should receive a confirmation email

  @edge-case
  Scenario: Registration with existing email
    Given a user exists with email "[email protected]"
    When I try to register with email "[email protected]"
    Then I should see an error "Email already registered"
```

## Requirements Quality

```yaml
quality_checks:
  acceptance_criteria:
    has_given_when_then: preferred
    is_testable: required
    is_measurable: required
    no_ambiguity: required

  user_story:
    follows_template: "As a <role>, I want <feature>, so that <benefit>"
    has_acceptance_criteria: required
    estimated: preferred

  completeness:
    edge_cases_identified: required
    error_scenarios_covered: required
    non_functional_considered: preferred
```

## Sprint Integration

```typescript
await requirementsValidator.sprintReview({
  sprint: 'current',
  checks: {
    storiesComplete: true,
    criteriaValidated: true,
    testsLinked: true,
    coverageAdequate: true
  },
  gates: {
    minCoverage: 80,
    maxUntested: 2,
    requireDemo: true
  }
});
```

## Coordination

**Primary Agents**: qe-acceptance-criteria, qe-traceability-builder, qe-bdd-specialist
**Coordinator**: qe-requirements-coordinator
**Related Skills**: qe-test-generation, qe-quality-assessment

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →
requirements-author microsoft requirements-author — a skill for authoring and managing Business Requirements Documents (BRD) and Product Requirements Documents (PRD) across Discover, Define, and Govern phases. Works with canonical templates and phase handoff contracts. CX Codex +1 ★ 1,627repo stars cucumber-best-practices TheBushidoCollective cucumber-best-practices teaches coding agents to write declarative Gherkin scenarios and maintain independent Cucumber tests. Clean step definitions without UI selectors. CX Codex +1 154installs 058-design-bdd Juan Antonio Breña Moral 058-design-bdd — a skill that takes Java teams through Behavior-Driven Development as collaborative discovery practice. Works with trusted behavior facts, concrete examples, and scenarios in shared domain language. CX Codex +1 135installs distill kirkchen distill turns existing code into draft BDD specifications written as Gherkin .feature files. It fits retroactive adoption of the Beat workflow for a module or codebase. CX Codex +1 533installs behavior-driven-development FradSer behavior-driven-development — a BDD skill for feature work, bug fixes, and executable tests. It turns behavior examples into failing tests before implementation. CX Codex +1 151installs add-cucumber-tests Decathlon add-cucumber-tests turns a functional specification into Cucumber .feature files, using Tzatziki step definitions as the source of legal steps. Built for Java/Spring projects that already depend on Tzatziki or Cucumber. CX Codex +1 1,100installs

From the same set73

The whole set →
pentest-validation pentest-validation validates SAST and DAST scanner findings against non-production targets, filters out false alarms, and produces PoC exploit proof. CX Codex +1 147installs database-testing database-testing is a Claude Code skill for checking database schemas, data integrity, migrations, transactions, and query performance. It applies to data persistence checks and schema changes. CX Codex +1 146installs performance-testing performance-testing is a Claude Code skill for planning load, stress, and soak tests, setting performance targets, and investigating bottlenecks in API and application results. CX Codex +1 144installs qe-test-generation qe-test-generation generates tests for new or changed code, with emphasis on contracts, invariants, and property checks. Use it to fill coverage gaps or move tests between frameworks. CX Codex +1 142installs refactoring-patterns Applies refactoring patterns. Runs when you need to improve code structure without changing behavior. CX Codex +1 140installs chaos-engineering-resilience chaos-engineering-resilience — a skill for injecting controlled failures into distributed systems, verifying recovery mechanisms, and validating resilience. Catches weaknesses before users do. CX Codex +1 138installs localization-testing The localization-testing skill checks translation coverage, locale-specific formats, RTL layouts, and Unicode handling. Use it when adding languages or preparing an international release. CX Codex +1 137installs sherlock-review sherlock-review is a skill for investigating code changes through evidence and deduction. It helps find bug root causes or verify fixes. CX Codex +1 135installs

Project sponsors

Companies that keep this analytics open