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.

Five-Gate Pipeline

Every test Quell generates must pass all 5 gates before it's written to disk. This is what makes WRITTEN tests trustworthy.

The gates

#	Name	Description	Failure →
1	AST Valid	Parses to valid Python AST	Regenerate
2	Original	Not already in any test file	Skip (duplicate)
3	Secure	No shell calls, no filesystem writes, no network	FLAGGED
4	Passes Correct	Runs against original (correct) code — must pass	SCAFFOLDED
5	Fails Violated	Runs against violated code — must fail	SCAFFOLDED

Gate 4: Passes Correct

Quell runs the generated test against your original, unmodified source code. The test must pass.

If it fails, the test has a bug — Quell won't write it.

Gate 5: Fails Violated (THE MOAT)

This is what separates Quell from coverage tools.

Quell injects a violation into the source code — removes the guard, changes the condition — then runs the test. The test must fail.

If the test passes even with the violation, it doesn't catch the bug. Quell won't write it.

The source is always restored in a finally block after gate 5. No permanent changes.

Example: gate 5 in action

# Gate 4: runs against original code
def process_payment(amount: float) -> dict:
    if amount <= 0:          # guard intact
        raise ValueError(...)
    # → test passes ✓

# Gate 5: violation injected
def process_payment(amount: float) -> dict:
    # if amount <= 0:        # guard removed
    #     raise ValueError(...)
    pass
    # → test fails ✗  (violation detected!)

What happens when a gate fails

Gates 1–3: attempt to regenerate or mark as SCAFFOLDED
Gate 4: mark as SCAFFOLDED (test has a bug)
Gate 5: mark as SCAFFOLDED (test doesn't catch the violation)

A SCAFFOLDED result is not a failure — it's an honest acknowledgment that Quell couldn't prove this one automatically.