Skip to content

quelltest npm 0.3.1 is out. It checks that AI-written tests can really fail. See what's new

The free, offline gate for AI-written tests.

Prove your AI-written tests would catch a bug.

Your agent says the tests pass. quelltest runs them against deliberate bugs, and fails the build when a change weakens them. Nothing leaves your machine.

In plain words: it breaks your code on purpose, a little at a time, and checks that your tests notice.

~/my-app — quell

Would this test fail if the code were wrong? A mutant is a deliberate small bug.

npx quell verify tests/discount.strong.test.js --source src/discount.js
Verified: test killed 6/8 mutants (75%) [copy]
survived: ?? -> || (line 5)
survived: < -> <= (line 2)

Did this change make the tests weaker? Deleted, skipped and loosened tests fail the build.

npx quell gate --diff main
Gate failed: 4 issue(s) in 1 changed test file(s)
✖ tests/discount.test.js :: rejects negative prices — test deleted
✖ tests/discount.test.js :: accepts a price of exactly zero — test deleted
✖ tests/discount.test.js :: applies a percentage discount — assertions weakened (0 -> 1 weak, e.g. equality replaced by ok/truthy/not-null)
✖ tests/discount.test.js :: caps the discount at 50 percent — test is now skipped (skip/todo/x-prefixed)
exit=5

Where are the risky spots with no real test? The first lines from a three-file sample.

npx quell find src
Quell scan — 13 edge-case candidates, showing 10
• src/search.js:2 [regex-injection] search — user-controlled text reaches a regular expression; test input such as "(" or ".*" and escape it (medium)
• src/status.js:2 [unguarded-network-call] isHealthy — network call can reject or hang and nothing handles it; test a rejected call, a non-2xx status and a timeout (stub the client); set a timeout or signal (medium)
• src/plan.js:2 [throws] loadPlan — assert the error type and message ("userId required") (high)

Real output from quelltest 0.3.1. Sample project, Node.js 24, node:test.

Works with

  • Jest
  • Vitest
  • Mocha
  • Node.js

The proof

A green check is not proof.

A test can pass and still be unable to fail. Coverage only says the code ran. quelltest checks whether a test would notice a bug.

Break the code, watch the test.

  1. You or your agent write a test. It passes. The check is green.
  2. quelltest breaks your code on purpose, a few small ways, in a throwaway copy. Each deliberate bug is called a mutant.
  3. If the test still passes on broken code, it was never protecting that code.

The second check is the gate. An agent that writes both the code and the tests can make a test easier to pass. The gate compares the tests in a change with the version before it and fails the build when they got weaker.

Verify, a sample run

8 deliberate bugs in a small discount function. The test caught 6 and missed 2.

  • Caught (6): the test failed, good
  • Survived (2): nothing noticed
  • < to <= survived: no test tries a price of exactly 0. A real gap.
  • ?? to || survived: here the two behave the same, so you can mark it as ignored.

Gate, a sample change

tests/discount.test.js
test("applies a percentage discount", () => {
removed: assert.equal(applyDiscount(200, 10), 180);
added: assert.ok(applyDiscount(200, 10));
});
loosened assertion: gate failed (exit 5)

The test used to demand exactly 180. Now it accepts any truthy answer, and the build is still green. The gate is the one that says no.

  • 11 of 18

    known defects found

    bugs reported against a real code base

  • 0

    false alarms on 7 clean files

    guarded code raised no findings

  • 7 of 7

    weak tests rejected

    at the recommended 60% floor

From quelltest's own eval, on fixtures its authors wrote. Treat them as regression guards.How we measure

What you get

Four checks, in plain words.

quelltest asks one question: would your tests notice if the code were wrong? It answers by planting small deliberate bugs (we call them mutants) and watching what your tests do.

quell find srcuntested, riskiest first

  • path-traversal (high confidence)src/files.js:4download
  • throws (high confidence)src/shipping.js:3shippingCost
  • falsy-fallback (medium confidence)src/pay.js:8applyDiscount

Find the risky spots

quell find lists the untested places where bugs like to hide: guards, fallbacks and thrown errors.

Try it on a sample project
  • caught
  • caught
  • survived
  • caught
  • caught
  • caught
  • survived
  • caught

6 of 8 bugs caught

survived: ?? → || (line 5)survived: < → <= (line 2)

Check a test really tests

quell verify plants small deliberate bugs in a throwaway copy and checks that your test fails on them.

How verify works

tests/discount.test.js

Removed: assert.equal(applyDiscount(200, 10), 180);

Added: assert.ok(applyDiscount(200, 10));

✖ assertion loosened · exit 5

Catch weakened tests

quell gate compares your tests with main and fails the build when one was deleted, skipped or loosened.

How gate works
Claude: Done. The tests pass.
quelltest: 2 bugs not caught

Give your AI a referee

quell mcp lets Claude Code, Cursor or any MCP client run these checks on its own work, and see where it fell short.

Set it up for your agent

How it works

We break your code on purpose. Your tests should notice.

A test that still passes when the code is wrong is not protecting you. quelltest finds those tests by experiment, on a copy, so nothing of yours changes.

npm package · JavaScript and TypeScript

How quell verify checks a testFour steps left to right. One: your test file and the code it tests. Two: a throwaway copy of the project with deliberate small bugs planted in it. Three: your tests run once on each bug. Four: a verdict for each bug, caught or survived. Example from a real run: 6 of 8 bugs caught, 2 survived. A dot travels along the arrows.1Your tests + codewhat you already havepay.test.jspay.js2Throwaway copyplus planted bugs3Run your testsonce per bugquell verify4The verdictcaught or survived6 caught2 survivedexample: a real run
  1. Step 1: Start with what you have

    Point quelltest at one test file and the code it tests. Jest, Vitest, Mocha and node:test all work.

  2. Step 2: Plant bugs in a copy

    quelltest copies your project and breaks the copy on purpose, one small bug at a time. Each one is called a mutant. Your real files are never touched.

  3. Step 3: Run your tests on each

    Your own test command runs once per bug. If a test fails, it caught the bug. If it still passes, the bug survived.

  4. Step 4: Read the verdict

    You see which bugs were caught and which survived, with a note on each survivor. Fewer survivors means a stronger test.

Read the verify guide

When someone changes a test

What gate checks

An AI agent can turn a red build green by editing the test instead of fixing the code. gate compares each changed test file with the version on main and fails if it got weaker. It only reads files, it never runs your tests.

npm package · JavaScript and TypeScript

What quell gate checksThree steps. One: a test file that changed in your working tree. Two: it is compared with the same file as it was on main, at the merge-base. Three: a verdict. The gate fails with exit code 5 if a test was deleted, a test was skipped, an assertion was loosened, or a .only was added. If none of those happened it passes with exit code 0. The gate only reads files and git history, it does not run your tests.1A changed test filein your working treepay.test.js2Compare with mainthe version before the change--diff main3Verdicttest deletedtest skippedassertion loosened.only addedany: exit 5none: pass, exit 0

Read the gate guide

Python package

Writing tests? Five gates before one is saved.

  1. Gate 1: Valid Pythonit parses
  2. Gate 2: Originalnot a duplicate
  3. Gate 3: Safeno eval, no network
  4. Gate 4: Passeson correct code
  5. Gate 5: Failson violated code
  • WRITTENAll five gates passed. The test is added to your test file.
  • SCAFFOLDEDNo safe automatic test, so you get a stub to finish.
  • FLAGGEDIt can't be tested automatically. You get the reason and the line.

Read how the five gates work

Two packages

One name, one for each language.

Both are free and open source. Pick the one that matches the language you write.

For JS and TS

quelltest for npm

Checks that AI-written tests would really fail if the code were wrong.

Works offline on JavaScript and TypeScript projects with Jest, Vitest, Mocha or node:test.

your-project
npm install -D quelltestnpx quell verify tests/discount.strong.test.js --source src/discount.jsVerified: test killed 6/8 mutants (75%) [copy]  survived: ?? -> || (line 5)  survived: < -> <= (line 2)
  • v0.3.1
  • Node.js 20+
  • Apache-2.0
For Python

quelltest for Python

Writes pytest tests for the rules already in your code, and proves each one works.

Reads docstrings, Pydantic models and type hints. Each new test must pass five checks before it is saved.

your-project
pip install quelltestquell find src/Quell Scan — reading guard clauses in 2 file(s)Logic Gaps Found (2 untested / 2 total)
  • v2.0.0
  • Python 3.11+
  • MIT

Not sure? Use npm for JavaScript and TypeScript, PyPI for Python.Which one should I pick?

Compared

Where it fits, and where it doesn't.

Use quelltest to check tests. Use Stryker for a full-suite mutation score. Use an LLM generator when you need tests written for arbitrary code, and put verify and gate in front of what it writes.

quelltest npm compared with Stryker and LLM test generators
CapabilityquelltestStryker (JS)LLM test generators
Free and open sourceYes: Free, Apache-2.0Yes: Free, open sourcePartly or not applicable: Paid or API-metered
Works offline, no model neededYes: No model, no networkYes: No model, no networkNo: Needs a model or network
Aims mutants at specific risksA mutant is a small deliberate bug.Yes: Yes, rule-drivenPartly or not applicable: Generic, configurablePartly or not applicable: Not applicable
Detects weakened tests in a changeYes: Yes (gate)No: NoNo: No
Built for coding agentsYes: MCP server, handoff reportPartly or not applicable: ReportsPartly or not applicable: Not applicable
Full-suite mutation scoreNo: No, per test file or changeYes: YesPartly or not applicable: Not applicable
Writes testsPartly or not applicable: Simple guards onlyNo: NoYes: Yes, arbitrary code

From public pages and papers as of 20 Oct 2026. Check each project for current details. The PyPI package is a different tool: it writes pytest tests and proves each one catches its violation.

For coding agents

Give your AI a referee.

An agent that writes the code also writes the tests that judge it. MCP (Model Context Protocol) is the plug that lets tools like Claude Code and Cursor call outside helpers. quelltest is a helper that checks the agent's tests against real bugs, and an agent can't talk its way around that.

Coding agents call quell mcp, which checks your tests on your machineCoding agents on the left (Claude Code, Cursor, and any MCP client) call quell mcp, an MCP server running on your machine over stdio, in the middle. It offers three tools: find lists risky untested spots, verify checks that a test catches bugs, gate catches weakened tests. quell mcp works on your tests and code on the right, which stay on your machine. Beams of light travel from the agents to quell mcp and on to your project.Claude CodeCursorAny MCPclientquell mcpan MCP server, over stdiofindrisky untested spotsverifydo tests catch bugsgateweakened testsno network callsYour tests + codestays on your machineonly verify runs tests

Add it to Claude Code

One line. Other MCP clients run the same command.

claude mcp add quelltest -- npx -y quelltest mcp

The agent can't say “done” until quelltest agrees

Add a Claude Code Stop hook that runs quell gate. If a test was weakened, the hook blocks the finish and tells the agent why.

npx quell gate --diff origin/main >&2 || exit 2

Add it under hooks → Stop in .claude/settings.json.

  • Both packages have an MCP server

    quell mcp (npm) offers find, verify and gate. The Python package has its own MCP server for Python projects; its docs list the tools it offers.

  • Local first

    The servers run on your machine over stdio and make no network calls. The optional Claude.ai connector gets sanitised metrics only, never source.

About the Claude.ai connector

Pricing

The core is free. Pay for the AI.

Both packages are open source and work fully offline. Paid plans add AI-assisted assessment and hosted features.

Show prices in

Free

$0₹0

The open-source core. Everything you need to gate AI-written tests, offline.

What you get

  • quelltest npm: verify, gate and find
  • quelltest PyPI: verified pytest generation
  • MCP servers for coding agents
  • CI gate with exit codes
  • No account and no API key
  • Community support
Install free

Team

$79₹6,599/month

For teams that need shared tracking and audit logs.

What you get

  • Everything in Pro
  • Claude connector (unlimited projects)
  • Cloud sync for unlimited projects
  • Up to 10 team members
  • Shared readiness dashboard
  • Audit log export
  • Dedicated support
Start Team trial

Every plan includes the offline rule engine. The Claude connector requires Pro or Team. Cancel anytime.

FAQ

Questions, answered.

Short answers in plain words. Still stuck? The docs go deeper.

Open the docs
Do I need an API key or an internet connection?

No. Both packages run locally. The npm package never sends code anywhere and needs no Docker. The PyPI package has an optional LLM fallback that you turn on yourself, and it is only used when the rule engine cannot handle a case.

Is Quelltest free?

Yes. Both packages are free and open source: the npm package is licensed Apache-2.0 and the PyPI package MIT. The npm gate runs offline on your machine.

What is the difference between the npm and PyPI packages?

The npm package is the gate for AI-written tests in JavaScript and TypeScript: verify proves a test would fail if the code were wrong, gate catches weakened tests in a change, and find lists risky edges with no real test. The PyPI package reads docstrings, Pydantic models and type hints, writes a pytest test for each gap, and proves each one catches the violation.

Will it modify my source code?

npm verify mutates a throwaway copy of your project in a temporary directory. Very large projects fall back to in-place mutation with a backup file, and you can force that with --in-place. The PyPI package injects a violation temporarily, always restores the original in a finally block, and only adds proven tests to your test files.

What does gate actually catch?

Deleted tests and test files, skipped or todo tests, .only, removed or reduced assertions, and equality loosened to ok, truthy or not-null. Changed expected values are listed as review items. It does not catch a test rewritten from scratch under a new name, or weakening done by changing the source instead.

Does it replace Jest, Vitest, Mocha or node:test?

No. It runs your existing tests against mutants and reports what they miss. Keep your runner, and keep property tests or contract tests where they fit.

Can I use it in CI?

Yes. gate exits 5 when it finds weakened tests and verify exits 4 when it cannot verify a test, so a plain script step fails the build. --sarif output can be uploaded for inline annotations on a pull request. See https://quelltest.com/docs/npm/ci and https://quelltest.com/docs/guides/ci-integration.

Can AI coding agents such as Claude Code or Cursor use it?

Yes. The npm package includes an mcp command and the Python package ships a local MCP server, so an MCP-capable coding agent can call Quelltest on your machine. Setup is described at https://quelltest.com/docs/npm/agents and https://quelltest.com/docs/mcp.

Which versions does it support?

quelltest on npm 0.3.1 needs Node.js 20+ (Node.js 22.18+ or 24.11+ from the next release from the next release). quelltest on PyPI 2.0.0 needs Python 3.11+.

What does it not do?

It does not give you a full-suite mutation score (use Stryker for that), and it does not write tests for most real code: generation handles simple, statically readable guards and leaves notes for the rest. Findings are review hints, not proof of defects.

Make the green check mean something.

Install it, point it at the test your agent just wrote, and see what survives.

Prefer to read first? Open the docs