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.

Privacy & Security

The connector is built on one rule: your source code never leaves your machine.

Does Claude see my source code?

No. The connector only receives a privacy-safe subset of your Quell report. Here is exactly what it can see:

What Claude sees	Example
Test names	`test_payment_rejects_zero_amount`
Confidence scores	`94` (0–100)
Confidence tiers	`HIGH` / `MEDIUM` / `LOW`
Flagged item locations	`src/billing.py:42`
Flagged item reasons	`external API: stripe.Charge.create()`
PRS score	`71/100`
Edge case counts	`23 total, 8 written, 3 scaffolded, 2 flagged`

What never leaves your machine

What stays local	Why
All source code	Your implementation logic
All test bodies	The actual `assert` lines Quell wrote
All docstrings	Your documentation
Variable names inside functions	Runtime state
Full file contents	Only `file:line` references are synced
Git history and diffs	Not relevant to the connector
Environment variable values	Never collected

Enforcement

The sanitizer (quelltest/sync/sanitizer.py) is the only code path that can produce an outbound sync payload. It enforces an allowlist — any field outside the allowlist raises SanitizationError before the network call is made.

The full published schema: quelltest.com/docs/sync-payload

Audit what was sent

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

Connector auth vs LLM auth

Connecting to Claude.ai is independent from enabling LLM fallback in the CLI.

Connecting the Claude connector does not enable quell find --use-llm
You can use the connector without ever enabling LLM fallback
They are separate opt-ins requiring separate authentication

Delete your data

quell sync unlink

This sends a DELETE /v1/projects/:id to api.quelltest.com and removes all synced reports. Claude will immediately lose access. The local sync history is also cleared.

Sync is always opt-in

sync = false is the default in [tool.quell]. Quell never auto-syncs.

[tool.quell]
sync = false  # default — must explicitly opt in

You must either set sync = true in config or pass --sync explicitly on each run.