Quality Testing — Objective Measurement of Code Quality

Philosophy

This skill guides the creation of tests and metrics that yield objective, verifiable numbers regarding the health of a codebase. The goal is not blindly pursuing 100%, but creating continuous visibility, establishing dependable baselines, detecting degradation before deployment, and driving data-informed refactoring.

Each quality dimension must be:

• Automatable: Collected in CI/locally without manual intervention.
• Trackable: Comparable across sprints and commits (trend > absolute).
• Actionable: When an indicator degrades, root cause and remedy are immediate.
• Contextual: Thresholds vary by architectural layer and domain criticality.

Complete Index of Quality Subskills

1. Formal Verification

• Formal Code Verification: Mechanical mathematical certainty of correctness by construction. Guides property declarations in LAWS.bend, demonstrations in PROOF.bend, and verification via the bend compiler.

2. Static Analysis, Linters & Typing

• Linting and Type Checking: Strict validation of type contracts and code standards in TypeScript (tsc --noEmit, ESLint Flat Config, Biome) and Python (mypy --strict, ruff).
• Static Application Security Testing (SAST): Scanning for known vulnerabilities (OWASP Top 10, CWEs) with Bandit, Semgrep, SpotBugs, and ESLint Security.
• Dead Code Detection: Identifying and eliminating orphan functions, variables, and exports with Vulture, autoflake, ts-prune, and knip.
• Code Duplication (DRY): Detecting code clones and duplicated snippets with jscpd, pylint --enable=duplicate-code, and PMD CPD.

3. Complexity, Hotspots & Maintainability

• Cyclomatic Complexity: Quantifying McCabe control flow paths, correlating with required test cases, and refactoring using guard clauses and polymorphism.
• Cognitive Complexity: Measuring code readability with nesting penalties via SonarQube and flake8 plugins.
• Module Size and Granularity: Thresholds for lines per file, lines per function, parameters, and classes to preserve the Single Responsibility Principle.
• Maintainability Index (MI): Composite score from 0 to 100 based on Halstead Volume, cyclomatic complexity, and LOC via Radon.
• Code Churn and Hotspots: Intersecting Git revision history with static complexity to prioritize refactoring where bugs actually occur.

4. Architecture, Coupling & Code Design

• Layer and Dependency Analysis: Preventing circular dependencies and safeguarding architectural boundaries with import-linter, ArchUnit, and dependency-cruiser.
• Afferent and Efferent Coupling: Analyzing coupling types (Content, Control, Stamp, Data), calculating $C_a$ and $C_e$, and extracting dependency graphs via AST.
• Martin Metrics (Abstraction, Instability, and Distance): Diagnosing Risk Zones (Zone of Pain and Zone of Uselessness) and distance $D$ from the Main Sequence.
• Connascence: Assessing coupling strength (Name, Type, Meaning, Position, Algorithm, Execution, Timing, Value, Identity) and applying strength reduction rules.

5. Dynamic & Executable Tests

• Code Coverage: Configuring branch coverage, layer-specific targets, and preventing coverage gaming (pytest-cov, vitest, JaCoCo).
• Mutation Testing: Evaluating actual test effectiveness by injecting synthetic faults via mutmut, Stryker, and PITest.
• Regression Testing: Snapshot testing for API contracts, consumer-driven contract testing with Pact, and Test Impact Analysis.
• End-to-End (E2E) Testing: Balanced testing pyramid, API-first scenarios, and browser automation with Playwright.
• Property-Based Testing: Validating universal invariants, roundtrip tests, and failure shrinking with Hypothesis and fast-check.
• Performance Testing & Benchmarks: Statistical micro-benchmarks (pytest-benchmark), performance budgets, and load testing with k6.

6. Governance & Continuous Integration

• Quality Gate & Dashboard: Weighted unified quality score (0-100) and consolidated GitHub Actions pipeline with fail-fast policies.

Decision Matrix: When to Apply Each Subskill

Recommended Implementation Phases

Phase 1 (Quick Wins)       ───► Lint, Type Check, Coverage, Dead Code, CC <= 10
Phase 2 (Architecture)    ───► Coupling (Ca/Ce), Dependencies, Martin Metrics (D)
Phase 3 (Depth)           ───► Mutation on Core, Connascence, Hotspots
Phase 4 (Rigor & Scale)   ───► Benchmarks/Load, Property-Based, Formal Verification (Bend)

Agent Instructions

1. Consult the dedicated subskill document before implementing tests or metrics in a specific technical area.
2. Type Check and Linter come first: Any static typing breakdown invalidates higher-level metric reliability.
3. Use the Bend skill when formal mathematical proof of critical algorithms is required.
4. Automate everything in the CI pipeline: Any test or metric that is not automatically executed on each PR will eventually be abandoned by the team.