Quell reads your docstrings, Pydantic models, and type annotations, extracts every testable requirement, finds which ones have no test, generates pytest tests via a rule engine, verifies each test through a 5-gate pipeline, and writes only proven tests to disk.

Does Quell require an LLM API key?

The rule engine runs entirely in-process — no source code is ever transmitted. ~75% of edge cases are handled with no network call and no API key. LLM fallback is opt-in and only sends the function signature, never the full body.

What is the 5-gate pipeline?

Every generated test must pass: Gate 1 (AST valid Python), Gate 2 (not already in a test file), Gate 3 (no shell calls or file writes), Gate 4 (passes against original code), Gate 5 (fails when the requirement is violated). Only gate-5-verified tests are written to disk.

What is the Production Readiness Score (PRS)?

PRS = (WRITTEN × 1.0 + SCAFFOLDED × 0.5) / total_requirements × 100. Tiers: 80-100 Production Ready, 60-79 Review Needed, 0-59 Needs Work.

How is Quell different from GitHub Copilot or Qodo for test generation?

Quell reads specifications that already exist in your code — it does not generate tests from scratch. It finds requirements already documented in your docstrings, Pydantic models, and type annotations that have no test. The 5-gate pipeline, especially Gate 5 (violation injection), verifies each test actually catches the bug it claims to catch. This verification step is not present in Copilot, Qodo, or Hypothesis.

Can Quell be used in CI pipelines?

Yes. Run quell ci src/ --threshold 80 to fail CI if PRS falls below 80. Set prs_threshold in pyproject.toml under [tool.quell]. Works with GitHub Actions, GitLab CI, and any system that checks exit codes.

Can Claude Code or Cursor use Quelltest directly?

Yes. Quelltest ships a local MCP server: install with pip install quelltest[mcp], then add {"mcpServers": {"quelltest": {"command": "quelltest-mcp"}}} to your project's .mcp.json. The agent can then call find_edge_cases, write_verified_tests, get_prs_score, prove_file, and reproduce_bug directly — no terminal needed. A Claude Code plugin is also available via /plugin marketplace add quelltest/quelltest-lib.

Does the Quelltest MCP server send my code anywhere?

No. The local MCP server (quelltest-mcp) runs entirely on your machine over stdio — no cloud, no network calls, no telemetry. The separate opt-in Claude.ai connector only ever transmits sanitized metrics (PRS score, bucket counts, test names, flag locations); a sanitizer blocks source code, function bodies, and docstrings structurally.

How do I add Quelltest as a Claude.ai connector?

In Claude.ai, go to Settings, then Connectors, then Add custom connector, and enter https://mcp.quelltest.com. Claude discovers the OAuth endpoints automatically and walks you through authorization.

✦New: Quell now has a Claude connector — ask Claude about your production readiness in plain English.See how it works →

NEW — MCP server + Claude connector

Proof, not coverage.

Quelltest reads the specs already in your Python code, finds the edge cases nothing tests, and writes pytest tests it has proven catch real bugs — for developers and QA engineers burned by green dashboards.

Start free

rule engine — no API keyruns offlineMIT licensed

✓ 8~ 3⚑ 2· PRS 84

test_payment_rejects_zero.py

def test_payment_rejects_zero():

with pytest.raises(ValueError):

process_payment(amount=0)

gate 5 — violation caught

Watch a runFIG. 00 — LIVE PROOF

quelltest — local runrunning

➜ $

How it worksFIG. 01 — VERIFICATION PIPELINE

Plugs into the stack you already run

Claude.ai— native connectorMCP— server built-inpytest— output formatGitHub Actions— quell ciPyPI— pip install quelltestPython 3.11+— typed, Pydantic v2

verification gates

every WRITTEN test passes all five

honest buckets

WRITTEN · SCAFFOLDED · FLAGGED

rule engine coverage

deterministic — no network, no tokens

local by default

source code never leaves your machine

The moat

Coverage tools stop at Gate 4.

Gate 5 injects the violation into your source and requires the test to fail. A test that can't catch the bug it claims to catch gets discarded — not shipped.

FIG. 02 — GATE CORRIDOR

Honest output

Every requirement lands in
exactly one bucket.

FIG. 03 — TRIAGE

✓WRITTEN

Proven by all 5 gates. Written to disk with libcst — formatting preserved.

pytest file, ready to commit

~SCAFFOLDED

Needs state Quell can't fake — external APIs, DBs. You get a stub with the assertion sketched.

stub + TODO, 5 min to finish

⚑FLAGGED

Can't be safely tested automatically. You get the location and a one-line reason.

src/billing.py:142 — external API

One command

quell find src/ --fix

No test plans, no prompts, no YAML. Point it at a directory.

READ

AST-scans docstrings, Pydantic models, and type hints. Zero annotations, zero config.

PROVE

Generates a test per gap, then runs all five gates — including injecting the violation.

WRITE

libcst injection with backup and restore. Only proven tests reach your files.

The score

One number your whole
team can watch.

FIG. 04 — PRS

WRITTEN

SCAFFOLDED

FLAGGED

avg confidence 91%·13 edge cases

80–100Production Ready

60–79Review Needed

0–59Needs Work

PRS across runs+22 in five runs

PRS = (WRITTEN × 1.0 + SCAFFOLDED × 0.5) / requirements × 100

scaffolds decay after 7 days — stubs you ignore cost you points

# fail CI below threshold
$ quell ci src/ --threshold 80

NEW — MCP SERVER + CLAUDE CONNECTOR

Ask your codebase
how ready it is.

Connect Quelltest to Claude.ai and query production readiness in plain English — PRS trends, flagged gaps, scaffold debt. Your source code never makes the trip.

ArchitectureFIG. 05

claude.ai — quelltest connectedconnected

What's blocking us from 80 PRS on payments-service?

Two things. test_refund_idempotency has been scaffolded for 11 days (−5 PRS), and billing.py:142 is flagged — it calls stripe.Charge.create() directly, so Quell can't inject a violation into a live call. Mock that call and Quell writes the test on the next run.

Show the PRS trend for the last 5 runs.

62 → 68 → 71 → 79 → 84. Crossed into Production Ready on Tuesday's run after the boundary tests landed.

Add to Claude.ai Browse the 8 MCP toolsSettings → Connectors → https://mcp.quelltest.com

The boundary

Your source code is
structurally unable to leave.

Cloud sync is opt-in and passes through one gate: a sanitizer that raises on any blocklisted key. It isn't a policy — it's the only code path out.

FIG. 06 — PRIVACY BOUNDARY

VERSUS

Most tools run one gate.
We run five.

Feature	Quell quelltest	GitHub Copilot	Qodo (CodiumAI)	Hypothesis
Reads existing specs (no annotation)	✓	✗	✗	✗
Deterministic rule engine (no LLM needed)	✓	✗	✗	✓
Gate 4: test passes on correct code	✓	partial	partial	✗
Gate 5: test fails on violated code	✓	✗	✗	✗
Offline by default — rule engine needs no API key	✓	✗	✗	✓
Writes verified tests to disk (libcst)	✓	✗	✗	✗
Three-bucket output (WRITTEN / SCAFFOLDED / FLAGGED)	✓	✗	✗	✗
PRS production readiness score	✓	✗	✗	✗
Source code stays on disk — nothing transmitted	✓	✗	✗	✗
Supports Pydantic + PySpark schemas	✓	✗	partial	✗
Claude.ai native connector	✓	✗	✗	✗
MIT licensed, runs in CI	✓	✗	✗	✓

Comparison as of June 2026. Information sourced from public documentation.

PRICING

Free to start.
Scale when you need to.

Hobby

Free

For individuals exploring Quell on personal projects.

✓500 verifications / month
✓Python docstrings + Pydantic
✓3-bucket output
✓CLI access
✓Community support
✓MIT licensed

Get started free

Pro

Questions, answered.

No. The rule engine handles ~75% of cases with zero network calls and no API key. MUST_RAISE, MUST_RETURN, BOUNDARY, ENUM_VALID, NOT_NULL, and TYPE_CHECK are all pure rule-based. The LLM fallback is optional and only activates on complex cases you opt into.

Stop shipping
untested edge cases.

Quell reads your existing specs, finds the edge cases with no tests, and writes verified pytest tests to disk. Every test is proven to fail when the bug is injected. Gap-first. Confidence-first.

Start for free Read the docs

$pip install quelltest

MIT licensed · Python 3.11+ · runs offline · rule engine, no API key

Proof, not coverage.

Coverage tools stop at Gate 4.

Every requirement lands inexactly one bucket.

quell find src/ --fix

One number your wholeteam can watch.

Ask your codebasehow ready it is.

Your source code isstructurally unable to leave.

Most tools run one gate.We run five.

Free to start.Scale when you need to.