Agent detects edge case → writes test → fixes bug → ships

At Level 5 (Autonomous), the complete quality loop runs without human initiation: an agent identifies a potential edge case or bug through code analysis, static analysis, or production signals; writes a failing test that reproduces the issue; implements the fix; verifies that all tests pass (including the new one); and submits the PR. A human may review the PR, but the discovery, diagnosis, test authoring, implementation, and submission all happen without a human prompt.

This is the endpoint of the testing strategy maturity arc. At L1, humans write tests manually and skip them under pressure. At L2, AI generates unit tests. At L3, requirements become acceptance tests. At L4, agents iterate to green in sandboxes. At L5, agents find problems that humans haven't noticed, fix them without being asked, and ship the fix as a complete, tested PR.

The loop consists of four distinct phases. Detection: the agent uses static analysis, code pattern recognition, specification comparison, or production signal analysis to identify a potential defect. A classic example: an agent reads a function that handles numeric division without checking for zero denominators, and identifies the unhandled edge case. Test writing: the agent writes a failing test that demonstrates the issue - a test that will fail against the current implementation and pass once the bug is fixed. This test is derived from the detected edge case specification, not from the implementation, so it is not circular. Fix implementation: the agent implements the fix, iterates in sandbox until all tests pass, including the new one. Submission: the agent submits the PR with the test, the fix, and a clear explanation of the detected edge case, the test, and the resolution.

This loop is not hypothetical at L5 - it is the normal operating mode for quality improvement. The agent fleet continuously scans the codebase, production signals, and specification coverage for potential defects, and the queue of automatically-fixed bugs runs continuously in parallel with feature development.

The detect-test-fix-ship loop represents the highest leverage possible from the testing investment:

• Bugs fixed before reports - Defects are detected and fixed before any user encounters them. The cost of a bug that is never reported because it was fixed proactively is dramatically lower than a bug that reaches production.
• Quality improves continuously without allocation - At L1-L4, quality improvement requires explicit sprint allocation: "this sprint we fix technical debt." At L5, quality improvement runs continuously as a background process, requiring no explicit allocation.
• Coverage grows automatically - Every detected edge case adds a test. Coverage is not a periodic initiative; it's a continuous output of the quality loop.
• The velocity ceiling is lifted - At L1-L3, quality work and feature work compete for the same engineering time. At L5, they run in parallel on separate tracks. Feature agents produce features; quality agents improve quality. Throughput on both tracks increases.
• Human attention is reserved for judgment - The quality loop is not fully unattended. Humans review submitted PRs, handle escalations when the agent is uncertain about correct behavior, and set quality policy. But the execution is autonomous. Human judgment is focused, not diffused across routine maintenance.

1. Implement detection signal sources - The loop requires at least one detection mechanism. Start with the most structured: static analysis tools (ESLint, Semgrep, custom rules) that flag specific code patterns as potential bugs. This gives the agent a structured input to reason about. Add production signal analysis and specification-gap analysis later.
2. Build the test-before-fix discipline - Configure the autonomous loop to always write the failing test before implementing the fix. This is a process constraint, not a technical one. The constraint prevents the agent from implementing fixes without verifiable tests, which would recreate the L1 coverage-without-verification problem at autonomous scale.
3. Integrate with sandbox CI - The full loop must operate in a sandbox before submitting to shared CI. The agent should detect, test, fix, and verify - all in an isolated environment - then submit a PR to shared CI only when everything is green. This is the same sandbox infrastructure from L4, applied to the autonomous quality loop.
4. Set confidence thresholds for autonomous submission - Not every detected edge case warrants autonomous submission. The agent needs a confidence model: how certain is it that the detected pattern is a real bug, not a false positive? Define the confidence threshold above which the agent submits autonomously, and below which it escalates to a human with a clearly framed question.
5. Implement the escalation protocol - When the agent detects a potential defect but cannot determine the correct behavior from available context, it should escalate with a specific question: "This function handles X but not Y. What should the behavior be when Y occurs?" The escalation includes the test the agent would write for each possible answer, so the human can confirm without doing additional work.
6. Monitor the loop's output quality - Track: detection accuracy (what fraction of detected "bugs" are confirmed by human review to be real bugs), fix correctness (what fraction of submitted fixes pass human code review without modification), and regression rate (what fraction of auto-fixed bugs recur). These metrics tell you whether the autonomous loop is operating with genuine quality or generating noise.

Autonomous loops fixing things that aren't broken. An agent with low-confidence detection will generate PRs for "bugs" that are actually intentional behavior. This creates review burden (humans must assess each PR) and erodes trust in the autonomous system. Calibrate detection confidence carefully and start with high-confidence patterns (division by zero, null dereference, off-by-one in range checks) before expanding to ambiguous patterns.

The loop creating circular fixes. An agent that detects a behavior, writes a test, implements a fix, and finds the test now passes may have just changed the behavior - not fixed a bug. If the original behavior was intentionally specified somewhere (a ticket, a product requirement), the agent may have "fixed" a feature into a bug. The detection pipeline must cross-reference against requirements before flagging behaviors as defects.

Runaway loops without human checkpoints. A fully autonomous quality loop with no human checkpoints can operate for days before anyone notices it has been generating incorrect fixes. Implement daily summaries: "The quality loop submitted N PRs today, of which M were auto-merged and K are awaiting review." Humans should see the output volume and be able to intervene quickly if something looks wrong.

Treating the loop as a substitute for architectural decisions. The autonomous quality loop finds and fixes local bugs - specific functions with specific edge cases. It does not identify structural problems: architectural flaws, design patterns that produce bugs systematically, or missing abstractions that cause bugs in multiple places. Architectural quality decisions remain human work.