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.

Ask Claude About Your Edge Cases — Quell Now Has a Claude Connector

Today we're shipping Quell v2.0.1 with one headline feature: a Claude connector.

Connect Quell to Claude.ai and ask about your production readiness in plain English.

User: What's blocking us from 80 PRS on the payments module?

Claude: Two things: test_refund_idempotency is scaffolded and 11 days old
        (that's −5 PRS). And billing.py:42 is flagged because it calls
        stripe.Charge.create() directly — Quell can't inject a violation
        into a live Stripe call. If you mock that call, Quell can write
        the test next run.

No terminal. No JSON. Just a conversation about the things you actually care about: which edge cases are untested, why they couldn't be auto-tested, and what to do about them.

How it works

Quell's local engine is unchanged. It still runs offline. Your code still never leaves your machine.

What's new is quell find --sync. When you add that flag, Quell pushes a privacy-safe subset of your report to api.quelltest.com — test names, confidence scores, flagged reasons, PRS, and file:line locations. That's it. No source code. No test bodies. No docstrings.

The Claude connector reads that subset and lets Claude answer questions about it.

# Scan + write tests + push report to cloud
quell find src/ --fix --sync

# Then in Claude.ai: "What is my PRS for payments-service?"

What Claude can answer

There are 8 tools the connector exposes:

list_projects — "What projects does Quell know about?"
get_prs_report — "What's my PRS?" / "Walk me through the latest report"
get_prs_history — "Is my PRS improving?" / "When did we drop below 80?"
get_written_tests — "Which tests should I review before merging?"
get_flagged_items — "Why can't those two be auto-tested?"
get_scaffolded_items — "Which stubs have I not finished?"
get_badge_url — "Give me the README badge markdown"
reproduce_via_cloud — "Write a failing test for this bug description" (Pro/Team)

Privacy is non-negotiable

We spent more time on the privacy model than on any other part of this feature.

The sync payload has a published schema at quelltest.com/docs/sync-payload. The sanitizer (quelltest/sync/sanitizer.py) is the only code path that can produce an outbound payload. It enforces an allowlist — any field outside the allowlist throws SanitizationError before the network call is made.

What the connector never receives:

Source code (any function body, any class body)
Test bodies (the actual assert lines Quell wrote)
Docstrings
Variable names from within functions
Full file contents
Git history or diffs

You can verify what was sent at any time:

quell sync status --privacy

Sync enabled: yes (Pro tier)
Project: payments-service
Last push: 2026-06-07 10:00:00
What gets sent: test names, confidence scores, flagged reasons, PRS, file:line
What stays local: all source code, all test bodies, all docstrings
View full schema: https://quelltest.com/docs/sync-payload

And if you want to delete everything from the cloud:

quell sync unlink

That sends a hard delete to the API. Claude immediately loses access. Nothing retained.

Sync is always opt-in

sync = false is the default. Always. We will never auto-sync.

You opt in by adding to pyproject.toml:

[tool.quell]
sync = true
sync_project_alias = "my-service"

Or by passing --sync explicitly each run. No silent background pushes. Ever.

The connector vs LLM auth

These are independent. Connecting Quell to Claude.ai does not enable LLM fallback in quell find. They are separate opt-ins:

Claude connector — reads your reports, answers questions in Claude.ai
LLM fallback — generates tests for the ~25% of cases the rule engine can't handle

You can use the connector without ever enabling LLM fallback, and vice versa.

Getting started

You need Quell v2.0.1 and a Pro or Team account.

pip install --upgrade quelltest

quell auth login
quell find src/ --fix --sync

Then open Claude.ai, go to Settings → Connectors, and add the Quell connector. Until Quell appears in the Anthropic connector directory (submission is in progress), you can connect directly using the server URL:

https://mcp.quelltest.com

Full setup docs at quelltest.com/docs/connector.

What's next

The connector is the first step toward making Quell's results usable outside the terminal.

Next up: the VS Code extension (Q3 2026) so you can see FLAGGED items as inline squiggles while you code. And the Team dashboard (Q4 2026) for shared PRS tracking across all repos in your org.

The rule engine stays offline. The sync stays opt-in. The source code stays on your machine.

That's the deal.

— Shashank