Blog
Edge-Case Testing, npm, Python & Production Readiness
Engineering decisions, tutorials, and product updates from the Quell team.
Did the AI Weaken Your Tests? Catching Deleted, Skipped and Loosened Tests With quell gate
quell gate compares test files with their merge-base version and fails on deleted, skipped, .only and loosened tests. A real diff and its real output.
Does Your Test Fail When the Code Is Wrong? How quell verify Works
quell verify runs a test on the original code, then on mutants in a throwaway copy, and rejects tests nothing can break. Real output, with a rejection.
The Gate for AI-Written Tests: Introducing quelltest 0.3
quelltest 0.3 proves a test fails when the code is wrong, flags weakened tests in a diff, and finds untested risky edges. Free, offline, Apache-2.0.
One Verification Layer for Jest, Vitest, Mocha and node:test
How quelltest detects your runner, what its runner matrix proves, and the exact verify and generate commands for Jest, Vitest, Mocha and node:test.
Giving Claude Code, Cursor and Other Agents a Verifier: The quelltest MCP Server and a Stop Hook
Run npx quelltest mcp to give any MCP client find, verify and gate tools, and add a Claude Code Stop hook that blocks done when tests were weakened.
quelltest on npm or PyPI? A Guide to Picking the Right Package
Two packages share the name quelltest: npm for JavaScript and TypeScript, PyPI for Python. Language, licence, runtime, install lines and limits compared.
Testing Code That Calls APIs and Services: What quelltest 0.3.1 Does About It
quelltest 0.3.1 derives stubs from the guards on a call's result, restores fetch after each test, and checks stubs against recordings. And what it cannot know.
Edge-Case Testing for JavaScript and TypeScript Without Replacing Your Test Runner
How quelltest for npm finds untested risky edges in JavaScript and TypeScript, scores them only from coverage evidence, and leaves your runner in charge.
Vitest, Jest, or node:test? A Practical Edge-Case Testing Workflow
A runner-neutral workflow for Node teams on Vitest, Jest, Mocha or node:test: find gaps, verify tests can fail, gate weakened tests, with the right flags.
Quelltest Is Now Agent-Native: A Local MCP Server Ships in the Package
The Python repo ships a local MCP server and Claude Code plugin so agents can find untested edge cases and write proven pytest tests, all on your machine.
I Let Claude Code Write All My Tests for a Week. Here's What It Got Wrong.
Field notes from a week of fully agentic test writing — what AI test generation nails, where it quietly fails, and why 'the tests pass' is the least interesting thing a test can tell you.
What 10 Years of Research Actually Says About Test Coverage
Coverage is the most-measured number in testing and one of the least predictive. A tour of the peer-reviewed evidence — Inozemtseva & Holmes, Defects4J, Google's mutation testing program — and what it means for how we gate CI.
AI Writes the Code Now. Who Proves It?
Agentic coding went mainstream this year. The bottleneck quietly moved from writing code to trusting it — and most teams haven't noticed their review process was built for a slower world.
Ask Claude About Your Edge Cases — Quell Now Has a Claude Connector
You can now connect Quell to Claude.ai and ask about your production readiness in plain English. No terminal required. Your source code never leaves your machine.
Quell v2.0.0: We Stopped Generating Tests and Started Proving Things
v1 was a test generator. v2 is a proof engine with three buckets, five gates, and a score that tells you exactly how production-ready your edge cases are. Here's everything that changed and why we had to.
Your Test Coverage Is Lying to You
100% line coverage with zero edge case validation. It's more common than you think. Here's what the Production Readiness Score measures instead — and why it's the number that actually correlates with what breaks in production.
The 5-Gate Pipeline: Why One Check Isn't Enough to Trust a Generated Test
Most AI test tools run one check: does it parse? Quell runs five. Here's what each gate catches, what breaks without it, and why the order matters.
Why We Built a Verification Engine Instead of Just Generating Tests
Any tool can write a test that runs. We needed tests that prove something. Here's the engineering decision behind Quell's two-phase verification and why it makes all the difference.
100% Code Coverage Is a Lie — Here's What Actually Matters
Code coverage measures which lines ran, not whether your tests prove anything. Learn why coverage is a vanity metric and what to track instead.
Your Docstrings Are Already a Test Spec — You're Just Not Using Them
Python docstrings contain every testable requirement your functions have. Learn how to turn Raises:, Returns:, and Args: blocks into verified pytest tests automatically.
What Is Mutation Testing — and Why Your Team Keeps Skipping It
Mutation testing is the only way to prove your tests actually catch bugs. Here's why teams avoid it and how to get its benefits without the pain.
Your Pydantic Models Are Already Test Specifications — You're Just Not Using Them
Every Pydantic model is a machine-readable contract. Learn how to turn validators, field constraints, and discriminated unions into verified tests without writing a single test manually.
The Hidden Cost of Skipped Edge Cases in Python APIs
Edge cases are not rare. They're the exact inputs real users send when they're confused, impatient, or adversarial. Here's what skipping them actually costs.
pytest Is Not the Problem — Verification Is
pytest is an excellent framework. The gap isn't the tool — it's that most test suites verify execution, not correctness. Here's the distinction and how to close it.