More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Edgehunt: tests that find the edge cases

    1

    Writes behaviour-first tests for a function or file: happy path, boundaries and errors, one clear assertion each, in your test framework.

    Free

    2 usesSecurity scanned
    Edgehunt: tests that find the edge cases

    Edgehunt: tests that find the edge cases

    Example session with this skill installed

    maji-test src/auth.ts:validatePassword

    function validatePassword(pass: string): boolean {
      return pass.length >= 8 && /[0-9]/.test(pass);
    }
    
    • Read your context and instructions
    • Compiled the edgehunt

    I have analyzed src/auth.ts and prepared a test plan for the validatePassword function using your project's Vitest configuration.

    src/auth.test.ts

    describe('validatePassword')

    ✓ test cases listed by priority:

    Happy path
    - returns true for 8+ characters with a number
    - returns true for long strings with multiple numbers

    Edge cases
    - returns false for exactly 7 characters
    - returns false for empty string
    - returns false for whitespace-only string

    Error cases
    - returns false for non-string input
    - returns false for string without numbers

    import { describe, it, expect } from 'vitest'
    import { validatePassword } from './auth'
    
    describe('validatePassword', () => {
      it('returns true when password is 8 characters and contains a number', () => {
        const result = validatePassword('pass1234')
        expect(result).toBe(true)
      })
    
      it('returns false when password is empty', () => {
        expect(validatePassword('')).toBe(false)
      })
    
      it('returns false when password lacks a number', () => {
        expect(validatePassword('justletters')).toBe(false)
      })
    
      it('returns false when password is under 8 characters', () => {
        expect(validatePassword('p1')).toBe(false)
      })
    
      it('returns false for non-string input', () => {
        // @ts-expect-error testing runtime safety
        expect(validatePassword(12345678)).toBe(false)
      })
    })
    

    Next steps

    1. Run npx vitest src/auth.test.ts to verify the generated cases.
    2. If a specific edge case is missing, use maji-test "handle special characters".

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

    About this skill

    Writing tests often feels like a choice between meaningless code coverage or hours spent mocking complex internals. This skill enforces disciplined test generation by focusing on external behavior, edge cases, and readable naming conventions rather than implementation details.

    What it does

    • Targeted generation creates tests for specific functions, entire files, or specific failing scenarios.
    • Behavioral focus prioritizes happy paths, boundary conditions, and error states over internal logic.
    • Clean naming enforces a strict subject-behavior-condition pattern for maximum readability.
    • Minimalist setup ensures tests are concise and avoid "mocking the world" unless crossing a boundary.

    How it works

    1. Context check involves the agent scanning your project manifest and config to detect your testing framework.
    2. Targeting occurs when you run Edgehunt <target>, specifying a function, file, or scenario.
    3. Plan generation lists prioritized test cases across happy paths, edge cases, and errors.
    4. Code generation produces the final test suite in your project's specific style and framework.

    Frameworks & tools

    This tool adapts to existing stacks including Jest, Vitest, Mocha, and Playwright. It supports TypeScript and JavaScript environments using standard assertion patterns.

    Why this beats prompting it yourself

    Generic prompts often produce bloated tests with multiple assertions and excessive mocking that become brittle. This skill applies a specific hierarchy of testing priorities and a "one assertion per test" rule that makes your suite easier to debug.

    Use cases

    • New feature coverage for quickly scaffolding the primary logic of a new module.
    • Regression testing by targeting a specific failing scenario to prevent it from reappearing.
    • Edge case discovery to identify boundary values like empty strings or type-coerced inputs you might miss.
    • Refactoring support to ensure public behavior remains stable while internals change.

    Known limitations

    It avoids snapshot tests for logic and does not test private internals. Integration tests involving databases or APIs are generated sparingly to maintain suite speed.

    Avoids snapshot tests for logic. Does not test private internals. Integration tests are generated sparingly to maintain speed.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Browser
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    maji test focuses on external behavior and edge cases rather than implementation details, ensuring your tests don't break every time you refactor internal logic. It also enforces a strict "one assertion per test" rule and clean naming conventions to keep your suite readable and easy to debug.

    The skill automatically scans your project manifest and configuration files to detect your specific environment. It currently supports Jest, Vitest, Mocha, and Playwright, working seamlessly with both TypeScript and JavaScript.

    It is designed for unit and unit-integration testing, prioritizing speed and stability. While it handles boundary conditions and error states, it avoids generating heavy integration tests for databases or APIs and does not support private internal or snapshot testing.

    No complex setup is required; once the skill is active, it uses a simple targeting command to scan your project context. It identifies your existing assertion patterns to ensure generated code matches your project's established style.

    You receive the full maji test skill logic, including prioritized test planning and code generation modules. Future updates to logic patterns and framework compatibility are included to ensure the skill evolves alongside the supported testing libraries.

    New in Testing & Debugging