How does maji test differ from just asking a standard LLM to write a test?

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.

Does this skill work with any testing framework?

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.

Are there any types of tests that maji test avoids generating?

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.

Do I need to manually configure my project's folder structure for this to work?

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.

What is included with my purchase of the maji test skill?

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.

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

Run npx vitest src/auth.test.ts to verify the generated cases.
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

Context check involves the agent scanning your project manifest and config to detect your testing framework.
Targeting occurs when you run Edgehunt <target>, specifying a function, file, or scenario.
Plan generation lists prioritized test cases across happy paths, edge cases, and errors.
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.

How to use

Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

Reviews

No reviews yet

Be one of the first to try it. Every listed skill passes our trust checks below.

Security scanned

Passed our 8-point scan before listing

1 install

Downloaded by developers to date

Free forever

No account required to browse

Edgehunt: tests that find the edge cases