Generators propose; verifiers dispose. The generate-then-verify pipeline decouples the creative act of producing candidates from the mechanical act of checking them — and the economics of that split explain most of the quality gains in modern AI systems.

The pattern's power comes from an asymmetry: verification is usually cheaper, more parallel, and more reliable than generation. Checking whether a piece of code passes a test suite is deterministic; writing code that passes is not. Verifying a claim against sources is bounded work; producing the claim requires synthesis across all of them. OpenAI's 2021 verifiers paper put numbers on the intuition: training a model to score candidate solutions and picking the best one beat best-of-n sampling substantially on GSM8K — provided the verifier was trained on enough data and, crucially, was not fooled by candidates that looked right.

The failure mode deserves equal attention: verifier gaming. When the generator and verifier are both learned systems, a generator can overfit to the verifier's quirks — solutions that pass the letter of the check while violating its spirit, the way reward-hacked agents exploit their reward functions. The defenses are structural: hold-out verifiers the generator never sees, adversarial audits of passing candidates, and — wherever possible — verifiers that are deterministic code rather than learned models.

Composition Patterns

• Best-of-n: generate n candidates, verify all, ship the first verified — the simplest reliable upgrade in applied AI.
• Verifier cascade: cheap checks first (schema, types), expensive checks last (full test runs, model-judged rubrics) so most candidates exit early.
• Verify-as-you-go: check each step inside a long chain rather than the final artifact alone — errors caught at step 3 are cheap; the same error at step 30 is archaeology.
• Generator feedback loop: verification failures become the generator's next prompt — the loop that powers AlphaProof-style systems and test-driven agents alike.

The pattern scales down gracefully, too: a single unit test around an LLM-generated SQL query is generate-then-verify in miniature. The question is never whether to verify — it is whether your verifier is independent, cheap, and hard to game. Those three properties are the whole design.