Aviator has outlined a seven-part framework called Aviator Verify that fundamentally restructures how engineering teams handle AI-generated code. The core philosophy is simple: agents verify, but people decide. Instead of pointing a model at a diff and asking for approval, the system codifies team standards into "invariants" and verifies changes against them using deterministic scripts and separate verifier agents. This approach aims to eliminate the fatigue of line-by-line reviews while keeping human judgment central to the process.

Codifying Standards as Invariants

The first step involves turning the tacit knowledge of senior engineers into explicit rules called invariants. These are standing checks derived from past PR comments and contribution guides, such as "Use the Money type for anything with a currency" or "No direct writes to the users table." Unlike instruction files like CLAUDE.md, which are inputs to the generation process, invariants are verification checks. They are drafted by analyzing team history but only go live after human approval, ensuring that the rules reflect actual team consensus rather than AI hallucinations.

Capturing Intent and Decisions

Rather than requiring lengthy upfront specs, the framework captures intent and acceptance criteria directly from the coding session. When an AI agent interacts with an engineer, every decision pointβ€”such as where state lives or how to handle dependency failuresβ€”is recorded. These core decisions are labeled by who made them, distinguishing between human and agent choices. This context is preserved in the pull request, allowing reviewers to evaluate the reasoning behind the code rather than just the syntax.

Evidence-Based Verification

The system generates a test plan based on the captured criteria and invariants, then dispatches verifier agents to a preview environment. These agents run scenarios and gather concrete evidence, including screenshots, database states, and server logs. Every verdict points to this evidence, ensuring that verification is structurally separate from generation. This prevents the common pitfall where the same model that writes the code also reviews it, sharing the same blind spots.

The New Review Workflow

Human reviewers no longer skim diffs line by line. Instead, they examine the intent, the recorded decisions, and the evidence provided by the verifier agents. The reviewer’s task is to answer one question: does the evidence match what the team agreed to build? They can approve, push back on specific decisions, or waive failed invariants with a reason. This shifts the review from a syntax check to a judgment call on architectural and behavioral correctness.

Continuous Improvement Loop

The process doesn’t end at merge. Waivers and recurring review comments feed back into the invariant registry, allowing teams to refine their standards over time. If an invariant is frequently waived, it signals that the rule may be incorrect or too narrow, prompting a rewrite. This creates a living document of engineering standards that evolves with the codebase, reducing repetitive feedback in future pull requests.

Key Takeaways

  • Invariants are deterministic checks derived from team history, not just AI instruction files.
  • Intent and core decisions are captured from the coding session, not upfront specs.
  • Verification uses separate agents and preview environments to produce evidence like logs and screenshots.
  • Human reviewers judge evidence and decisions, not raw code lines.
  • The system improves via a feedback loop where waivers refine the invariant registry.

The Bottom Line

This is a promising shift for teams drowning in AI-generated noise. By separating verification from judgment, we might finally stop pretending that skimming diffs is a viable strategy for agent-written code.