Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    requirements test traceability

    1

    Managing the gap between what you built and what you tested is manual, error-prone, and slow.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    requirements test traceability

    requirements test traceability

    Example session with this skill installed

    Create a traceability matrix for Project Alpha. Req-1 (High), Req-2 (Low). Test-A covers Req-1. Test-B covers Req-99. Analysis date: 2023-10-27.

    • Read your context and instructions
    • Compiled the requirements test traceability

    I have processed the requirements and test mappings for Project Alpha. The analysis identifies a coverage gap for Req-2 and one orphaned test.

    Requirements-to-Test Traceability — Project Alpha, 2023-10-27

    1. Coverage Summary

    • Total Requirements: 2
    • Total Tests: 2
    • Coverage Percentage: 50.0%
    • Weighted Coverage: 75.0%
    • Gaps Count: 1
    • Orphaned Tests Count: 1

    2. Traceability Matrix

    RequirementPriorityStatusTest CountTests
    Req-1HighCovered1Test-A
    Req-2LowUncovered0-

    3. Coverage Gaps

    • Req-2: No tests mapped to this low-priority requirement.

    4. Orphaned Tests

    • Test-B: Maps to non-existent requirement ID 'Req-99'.

    5. Weak Coverage Warnings

    • Req-1: High priority requirement covered by only 1 test.

    6. Warnings and Assumptions

    • Warning: Orphaned mapping detected for Test-B.
    • Assumption: Analysis based solely on the provided mapping list for Project Alpha.

    Next steps

    1. Review the orphaned mapping for Test-B to determine if Req-99 was renamed or deleted.
    2. Create at least one test case for Req-2 to achieve 100% coverage.
    3. Consider adding supplementary tests for Req-1 due to its High priority status.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Managing the gap between what you built and what you tested is manual, error-prone, and slow. This skill automates the generation of requirements-to-test traceability matrices, providing a deterministic view of your test coverage.

    What it does

    • Builds traceability matrices by mapping requirement records directly to test cases in a structured table.
    • Calculates coverage metrics including total coverage percentage and priority-weighted coverage for critical features.
    • Identifies coverage gaps by listing every requirement that currently lacks an associated test.
    • Detects orphaned tests that point to non-existent or deprecated requirement IDs.
    • Flags weak coverage specifically for critical or high-priority requirements that only have a single test mapping.

    How it works

    1. Data ingestion where the agent reads your requirements and test specifications, assigning source identifiers.
    2. Schema validation through the creation of a request.json file that maps IDs and priorities.
    3. Deterministic calculation using a dedicated script to compute metrics without manual rounding or estimation.
    4. Reporting via a structured output including a summary, matrix table, and specific gap analysis.

    Frameworks & tools

    This skill utilizes a Python-based calculation engine and adheres to strict JSON schema validation for requirement and test objects. It operates independently of specific testing frameworks like Jest or Pytest, focusing on the mapping logic between documentation assets.

    Why this beats prompting it yourself

    Standard LLM prompts often hallucinate coverage percentages or miss orphaned mappings in large datasets. This skill uses a self-contained script to ensure every calculation is mathematically accurate and every gap is explicitly identified based on hard links.

    Use cases

    • Generating a formal traceability matrix for project stakeholders or audits.
    • Auditing a test suite to find tests that no longer map to active requirements.
    • Identifying high-priority features that are under-tested before a release.
    • Validating the completeness of a test plan against a new set of requirements.

    Known limitations

    This skill analyzes mappings only. It does not generate test cases, analyze code execution, or verify the quality of the test logic itself.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse All Claude Skills.

    Does not generate test code. Does not verify test correctness. Requires clear requirement and test IDs. Analysis is limited to provided mappings.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Environment Variables
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill automates the creation of traceability matrices and identifies coverage gaps or orphaned tests, eliminating the manual errors and hallucinations common when using standard LLM prompts for large datasets.

    The skill is framework-agnostic; it processes data through structured JSON schemas, meaning it works with any testing tool (like Jest, Pytest, or Selenium) as long as you can provide requirement and test IDs.

    You will receive the core logic engine, the JSON schema templates for data ingestion, and comprehensive documentation on how to format your requirement and test records for analysis.

    No, this skill focuses on the logical mapping between documentation assets; it identifies which requirements lack tests, but it does not write the test code or execute tests against your codebase.

    Setup involves a simple one-time configuration of your data mapping in a `request.json` file, allowing the agent to deterministically match your unique requirement IDs to your test suite.