Autonomous Test Engineer

    1

    Risk-based autonomous testing agent for generating, executing, and triaging software regression suites.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Autonomous Test Engineer

    Example session with this skill installed

    Review the auth-service changes in the current directory, generate a risk-based test matrix for the new JWT flow, and provide the test code for Vitest.

    • Read your context and instructions
    • Compiled the autonomous test engineer

    I have analyzed the auth-service directory. The changes impact the JWT signing logic and token refresh rotation. I have identified three primary risk surfaces: secret rotation, token expiration, and malformed header handling.

    Risk-Based Test Matrix & Vitest Implementation

    Risk SurfaceTest CasePriorityExecution Status
    Token IntegrityVerify signature fails with mismatched secretHighNOT RUN
    ExpirationEnsure 401 response on expired TTLHighNOT RUN
    Refresh LogicConfirm old refresh token is invalidated after useMediumNOT RUN
    Header ParsingHandle missing 'Bearer' prefix gracefullyLowNOT RUN
    // auth-service/tests/jwt-flow.spec.ts
    import { describe, it, expect, vi } from 'vitest';
    import { signToken, verifyToken } from '../src/jwt-provider';
    
    describe('JWT Flow Regression Suite', () => {
      it('should reject tokens signed with an outdated secret', async () => {
        const token = signToken({ id: 1 }, 'old-secret');
        const result = await verifyToken(token, 'new-secret');
        expect(result.valid).toBe(false);
        expect(result.error).toBe('invalid signature');
      });
    
      it('should invalidate refresh tokens after single use', async () => {
        const user = { id: 123 };
        const firstAttempt = await rotateRefreshToken(user);
        expect(firstAttempt.status).toBe(200);
        
        const secondAttempt = await rotateRefreshToken(user);
        expect(secondAttempt.status).toBe(403);
      });
    });
    

    Next steps

    1. Authorize execution of npx vitest run auth-service/tests/jwt-flow.spec.ts to verify these cases.
    2. Review the rotateRefreshToken mock data to ensure it matches your Redis production schema.
    3. Integrate these tests into the .github/workflows/ci.yml file to prevent regressions.

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

    About this skill

    Manual testing and generic test generation often miss edge cases or fail to map back to specific code changes. This skill implements a risk-based testing workflow that identifies high-impact surfaces, generates targeted test cases, and triages failures with evidence. It treats every test as a verifiable experiment rather than a one-off script.

    What it does

    • Risk mapping creates a behavior-to-test matrix covering happy paths, negative cases, and failure modes.
    • Framework detection inspects existing repository configurations to match local testing conventions.
    • Test generation writes isolated, deterministic tests with stable fixtures for regression and new features.
    • Failure triage categorizes results into product defects, test defects, flakiness, or environment issues.
    • Evidence reporting delivers measured pass rates and execution logs while clearly marking unverified code.

    How it works

    1. Discovery analyzes the codebase, changed modules, and existing CI configuration to determine the test framework.
    2. Strategy builds a risk-based matrix based on user objectives and system constraints.
    3. Implementation writes tests using isolated fixtures and repository-specific patterns.
    4. Execution runs the test subset, capturing exact commands and exit codes for the final report.

    Frameworks & tools

    Works with any standard testing stack including Jest, Pytest, Cypress, Playwright, or JUnit. It adapts to the host environment's available CLI tools and shell permissions.

    Why this beats prompting it yourself

    Generic prompts often produce hallucinated test results or generic assertions that do not actually run. This skill enforces a strict verification loop, distinguishing between proposed code and executed evidence while mapping every test back to a specific risk surface.

    Use cases

    • Generate a regression suite for a high-risk refactor of a legacy module.
    • Triage intermittent CI failures by isolating flakiness from environment issues.
    • Map new acceptance criteria to a concrete behavior-to-test matrix.
    • Audit existing test coverage against documented project requirements.

    Known limitations

    Cannot perform destructive operations or access external networks without explicit authorization. Execution is limited to the tools and permissions provided by the host environment.

    Requires host environment tool permissions to execute tests. Cannot access external networks or modify destructive fixtures without explicit user approval.

    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 any payment.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    jest
    Node.js

    Permissions

    Read Files
    Listed1 month ago
    Updated13 days ago

    What's inside

    Frequently Asked Questions

    The agent performs a deep analysis of your codebase and CI logs to categorize failures as genuine product bugs, environment issues, or flaky tests, saving engineers hours of manual debugging.

    It is designed to be framework-agnostic and automatically detects your environment to work with industry standards like Playwright, Cypress, Jest, Pytest, and JUnit.

    Unlike a one-off prompt, this skill follows a strict verification loop that maps every generated test to a specific risk matrix, ensuring assertions are based on executed evidence rather than hallucinations.

    The skill includes the core autonomous testing logic, predefined risk-mapping templates, and a suite of diagnostic tools for environment-aware test execution.

    The agent operates entirely within the permissions of your host environment; it cannot perform destructive operations or access external APIs unless you explicitly grant those capabilities.

    New in Testing & Debugging