Introducing PRD-Driven Verification

Today, we're excited to announce the General Availability of PRD-Driven Verification, a new way to build production software with AI.

We believe this has the potential to unlock a huge cohort of citizen builders to create even more complex, production-ready software.

Creating Software with AI Is Easy. Trusting It Is Hard.

AI has made creating software dramatically easier. But generating code isn't the hard part of building production software.

The hard part is knowing who can access what, that the software behaves the way you intended, that changes don't introduce regressions, and that you can confidently deploy updates without reviewing thousands of lines of code.

PRD-Driven Verification Changes the Flow

Traditional AI development happens inside a long-running chat conversation. That works well for prototypes, but it doesn't scale to applications that evolve over weeks or months.

Requirements scatter across conversations, implementation details drift, and nobody has confidence that the application still matches what was originally requested.

PRD-Driven Verification supplements chat history with a living Product Requirements Document. Every feature, user flow, access pattern, business rule, and expected behavior is automatically documented in one place by the Synthetiq AI agent.

Each requirement is backed by real, verifiable tests, with recorded videos of the application performing the scenarios, and is continuously verified against the application as it changes.

Verifying Application Requirements

Previously, checking edits to an app required manual QA: creating multiple users with different scopes and roles, seeding sample data, and coordinating with users to walk through each scenario by hand.

Now builders can verify application behavior by reviewing the requirements, recorded videos, and results, instead of manually reproducing each workflow.

Verifying Behavior Changes

Anytime the AI agent edits an app, any feature additions, modifications, or removals appear as a change within the PRD, allowing builders to have a comprehensive view into what behavior, UX, or access has changed as a result.

Verifying Visual Changes

Synthetiq captures visual snapshots throughout the application so builders can review interface changes across every affected screen.

Visual differences are highlighted alongside the updated requirements, making it easy to inspect UI changes without manually navigating the application.

Verifying Authorization Changes

Changes to permissions are surfaced automatically, so builders can review which users gain or lose access to data, APIs, and application functionality before deploying changes.

Flagging Overly Permissive Access

The PRD automatically flags overly permissive permissions on endpoints, such as one that lets any signed-in user read every record or edit data they don't own, listing each one under a Needs attention count for the builder to review and confirm.

Collaboration & In-Document Iteration

PRD-Driven Verification allows teammates to review requirement changes, compare versions, and comment on individual features before changes reach production.

Comments can become actionable work items for the Synthetiq Desktop Agent, allowing a user to make application changes directly from the PRD.

Catching Issues Before and After Production

Verification Closes the Loop

The PRD's requirements are validated at build time. If a requirement fails verification, the AI Agent receives the results, updates the implementation and/or PRD requirements, and reruns verification until the documented requirements are satisfied.

Reproducing Production Issues

Production bugs are hard to reproduce locally: they often depend on multi-user scenarios and the specific state of the production environment, not a builder's dev and seed data.

Because the PRD captures how the app behaves across users, roles, and data, the Synthetiq Desktop agent can emulate complex, multi-user scenarios (even those across asynchronous or scheduled multi-step workflows), reproduce the bug, and use the reproduction to drive the fix.

More Than AI-Written Tests

This isn't simply the AI writing its own test suite. An agent that writes both the implementation and the tests that check it adds little trust.

What matters is that the PRD accurately reflects what the app code does, so that users can trust that the PRD is an accurate reflection of what the app code actually is.

The PRD system enables that with a set of guarantees:

Access control assertions are derived from the application code, not written by the agent. Static analysis fails the build if a test's contract doesn't match what the code enforces, or leaves an endpoint uncovered.
Algorithms, formulas, and metrics are tested through real application code, so the agent can't reimplement logic in a test and grade its own work.
Third-party calls are intercepted and mocked from the service's typed schemas. Tests never hit live services.
Every recording is the real app running end-to-end, against a real database with real user sessions and scopes.
Anything that can't be verified deterministically is surfaced for the builder to review.

For the full list, see the PRD Trust Model.

How Synthetiq Enables These Guarantees

The Synthetiq App Framework standardizes and constrains how applications define APIs, authorization, data access, and background jobs. The Service Framework standardizes how applications communicate with external systems through statically typed service gateways.

Those architectural constraints allow Synthetiq to automatically derive permissions, recreate realistic application scenarios, intercept external service calls, generate reproducible environments, and verify application behavior through static analysis and automated execution.

Available Today

PRD-Driven Verification is available today for every Synthetiq organization.

Learn more: