Latency to Quality — the Classical Toolchain, Adapted for the AI Era

Optimizing latency to quality code through the primary operations of read, analyze, and write — and everything else that happens around the code. The checkpoint stack human developers built (lint, format, typecheck, hooks, CI gates, security, supply chain, mutation, SDD) is not obsolete under AI authorship — it is the verification substrate the AI era depends on. Catalog + DAG economics + transfer matrix + the Wave 1.9 verify-stack adoption.

Thesis

Human developers spent forty years building a checkpoint stack around the edit loop — formatters, linters, type checkers, git hooks, CI quality gates, security scanners, supply-chain automation. That stack is not obsolete when AI writes the code; it is the verification substrate the AI era depends on. AI code violates conventions (models default to mainstream patterns from training data), references methods that don’t exist, writes tests that game line coverage, and ships 3× faster than review can keep up. Mechanical gates are the only thing that scales with that velocity.

Speed and quality are not a trade-off at the current frontier — they come from the same architectural moves (batch edits, fast-apply, deterministic codemods, parallel search; see /research/agentic-velocity). What the classical catalog adds is the verification half: the gate order, the gate thresholds, and the verify ladder that turns generated code into shipped code with measurable confidence.

Optimizing latency-to-quality therefore means two things: (1) put every check at the cheapest layer that can catch its error class, and (2) make the checks deterministic where determinism works, and reserve LLM judgment for exactly where it doesn’t — with no silent fallback between them (workspace §2).

The classical toolchain — curated catalog

Eleven categories, each with the canonical tools, purpose, and the AI-era verdict. The full per-tool latency classes and optimal applications live in the workspace doc _WORKSPACE-DOCS/ROADMAP-20260802-classical-tooling.md.

The pipeline as a DAG — ordering economics

The classical stack composes into a DAG with one invariant: each stage is the cheapest gate that can catch its error class, and every stage’s output feeds the next.

pre-commit (ms–s)        pre-push / merge queue (s–min)    post-merge (min)        scheduled (nightly)
lint-staged (staged)      full tsc --noEmit                  integration tests         full mutation sweep
format --check            lint (full) + security (fast)      perf-regression gate      full vulnerability scan
secret scan (gitleaks)    commitlint                         behavioral/agentic E2E    SBOM + SLSA re-verify
commitlint                coverage + mutation (changed)      cross-repo contract       renovate bump PRs
                          SAST (semgrep/CodeQL)              smoke + deploy gates      action SHA-pin audit
                          build (hermetic)
                          agentic code review

The reference DAGs in the wild (Addy Osmani 9-step no-skip; Autonoma 5-layer with path-filtered risk; Motomtech 5-gate; FutureAGI 4-stage agent CI; Zylos 5 agent-native gates) all converge on the same rule, restated as this paper’s thesis above.

AI-native analysis — what transfers, what breaks, what is new

Three shifts change the calculus when the author is an agent:

1. Authorship assumption breaks. "Traditional code review assumes the author understands the diff. With vibe-coded PRs, that assumption breaks" — gates must catch what review can’t (type errors, unverified behavior, regressions).
2. Volume triples. "AI ships three times more code, so you run three times more gates" — gates must be cheap per unit of code (Rust-toolchain consolidation, staged scoping).
3. The writer and the tester are the same model. Code and tests are authored in the same pass from the same misreading — a green suite proves self-consistency, not correctness. The behavioral gate and mutation score are the antidotes.

The through-line: deterministic where determinism works (format, lint, type, codemods, structural merge, mutation, secret scan), LLM where determinism structurally fails (review judgment, eval rubrics, behavioral testing, spec synthesis), never silent fallback, and receipts and provenance everywhere — because when "the model changed" is the bug, the record of what ran, on what inputs, by which model/skill version is the only trustworthy review input (ADR-009).

Wave 1.9 measurements

Wave 1.9 adoption (roadmap wave 1.9 — verify-stack SoTA)

• Per-repo verify command resolution in the write-router — config.verify.verify_commands[<repo>] with basename normalization and top-level fallback; rung3/rung4 no longer hardcoded null (unlocks full-suite experiment verdicts). Applied in both the primary and splice-preflight ladder paths.
• Format rung — runFormatStep runs a configured format_cmd with {paths} substitution after apply, before the ladder (the morph→prettier friction fix); recorded in stage latencies, never a verify rung.
• Mutation-score rung — new 5th rung (rungs_1_5 ladder), rung5_mutation_cmd + mutation_report_path + mutation_threshold; parses both classic and Stryker 9 report schemas, fails loudly on missing report or below-threshold score. extractSurvivors() returns structured survivors (file, line, mutator, replacement, reason) as prompt-ready evidence for test-fix agents — closing the loop between mutation score and actionable test work.
• Console Stryker wiring — @stryker-mutator/core + vitest-runner, stryker.conf.json (vitest runner, src/lib/** mutate, incremental, json reporter), test:mutation script, gitignore/eslint ignores for the sandbox. Baselines: roadmap-data.ts 63.21%.
• Behavioral verification rung (Wave 1.9 follow-up, Shiplight pattern) — rung 6 behavioral in the write/harness verify ladder (rungs_1_6 ladder), rung6_behavioral_cmd per-repo config with a Playwright smoke surface for the console; honors continue_on_failure and haltOnFailure like the other rungs. The "agent writes code AND its tests from the same misreading" gap now has a gate.
• Corpus-readiness watchdog — bench/check-pareto-corpus.mts reports usable vs the n≥20 pareto target against the live receipt corpus (live smoke: NOT-READY, 0/200 usable — all historical runs recorded pre-continue_on_failure).

Next steps

1. Execute the verify-ordering pareto (preregistered, paper_slug verify-ordering-pareto) on the LIVE corpus once it reaches n≥20 usable (complete per-rung) receipts — the corpus-readiness watchdog bench/check-pareto-corpus.mts reports the shortfall. Synthetic-but-measured execution (2026-08-03) already returned current-on-frontier null parity.
2. The behavioral verification gate (Shiplight pattern, merge_group-triggered) is LANDED as verify rung 6 (rungs_1_6) with a Playwright smoke surface; the remaining work is the operator decision on making it a default harness rung (port isolation, task-class default scope, env-vs-impl failure classification).
3. Wire survivor → subagent feedback into the harness dispatch prompt (extractSurvivors output as targeted test-fix input), gated on the mutation rung below threshold.
4. Prompt-as-code linting + offline mini-eval gates for the skills/KYM artifacts (Zylos Gate 1–3, FutureAGI Stage 1), mapped onto the AgentDefinition schema.
5. GitHub Actions audit — SHA-pin actions, scope tokens, review pull_request_target (the 2026-03 trivy-action compromise is the live warning). The three third-party actions in validate.yml were SHA-pinned on PR #18; the audit of the remaining workflow surfaces is the follow-up.