Property-Based Testing & Generative QA Engineer

About the Role

Our system is built on mathematical contracts: window validity, co-timing assumptions, stability conditions, and “refuse-to-claim” behavior when those conditions don’t hold. Traditional unit tests aren’t enough—most failures live in the space between parameters: weird combinations of drift, coherence collapse, multipath, clipping, resampling, and borderline windows.

This role turns that messy space into a disciplined testing engine using property-based testing and generative QA. You’ll encode invariants (“this must always hold”), generate thousands of structured scenarios, and shrink failures into minimal counterexamples with receipts.

In practice, you make “if notch does not dip…” an automated, reproducible, CI-enforced system—not folklore.

What You’ll Own

• Property-based testing framework: core generators, shrinkers, and invariants across delay calculus, estimators, validity gating, and pipeline semantics.
• Contracts-as-tests: translate mathematical and operational promises into executable properties with measurable tolerances.
• Scenario generation: structured generators for adversarial real-world conditions (drift, multipath, multi-source, nonstationarity).
• Failure minimization + triage: shrink failing cases to the smallest reproducible example and emit actionable diagnostic artifacts.
• CI integration: fast/slow test tiers, seed replay, artifact capture, and regression dashboards.

What You’ll Do

• Define invariants at the right abstraction level: rewrite/canonicalization preserves meaning, estimators behave under known conditions, invalid windows must not yield confident outputs, every output has a receipt.
• Build generators for delay-polynomial expressions, window schedules/drift models, synthetic signals with controlled coherence/interference, and pipeline configurations under constraints.
• Build shrinkers that reduce failing cases into minimal counterexamples (shorter expressions, fewer windows, fewer sources, simpler drift).
• Implement reproducibility: deterministic seeds, ordering, and “replay this exact failure” tooling.
• On failure, emit the artifacts engineers need: spectra/coherence curves, delay estimates vs ground truth, gating decisions + reasons, and receipt traces.
• Collaborate with DSP, formal methods, and validation teams so properties match the real contract language.

Concrete Deliverables

• A generative QA library (generators + shrinkers) covering delay-calculus objects, signal models/windowed scenarios, and pipeline configs.
• A property suite for core promises: rewrite correctness, estimator stability bounds, gating safety (“no false trust”), receipt completeness.
• A CI harness with a quick tier (per PR) and deep tier (nightly/weekly), including seed capture + replay and artifact bundling.
• A counterexample corpus: curated minimal failures that stay in regression forever.
• A triage playbook: failure categories + “next checks” mapping.

Required Qualifications

• Strong experience with property-based testing (Hypothesis, QuickCheck, ScalaCheck, jqwik, etc.) and generative techniques.
• Comfort encoding invariants/semantics: you can read a math/algorithm spec and turn it into executable properties.
• Strong programming skills (Python preferred; Rust/Scala/Haskell/TypeScript also great depending on stack).
• Experience building test infrastructure: CI integration, reproducibility, performance tuning, artifact management.

Preferred Qualifications

• DSP/estimation intuition (coherence, leakage, drift, multipath) sufficient to generate meaningful adversarial cases.
• Experience with grammar-based fuzzing / DSL testing (useful for expression/pipeline generators).
• Exposure to formal methods/specs (TLA+, Rocq/Coq) to align properties with proved invariants.
• Experience building oracle-free or metamorphic tests for statistical systems.

How You’ll Be Measured (First 60–90 Days)

• You deliver a first property-based suite that runs in CI and catches at least one real regression or hidden bug.
• Failures shrink to actionable minimal cases (engineers get 10-line counterexamples, not 10,000-line logs).
• Coverage increases meaningfully without brute-force explosion (structured generators, not random noise).
• “Notch does not dip” becomes a family of properties and counterexamples, not a manual bench story.

Working Style

• You assume edge cases are the product.
• You like tests that generate insight, not just pass/fail.
• You prefer deterministic, replayable failures with receipts and minimal counterexamples.

Title & Level

Property-Based Testing & Generative QA Engineer (senior IC; can scale to Staff if owning the generative QA platform), partnering with DSP/algorithms, systems, and validation.