Review and approve

Review is the only stage that needs you, so it is the stage the platform is designed around. You are not approving a document. You are approving a set of individual clauses, and each one stands or falls on its own.

The interface

The review view is a diff. Not a chat transcript, not a document with comments in the margin — a diff, because a diff shows you what changed since you last looked, and most of your attention should go there.

Each clause shows:

  • The clause itself, in the native spec format it will live in.
  • Its provenance: which parts of your request it came from, and which parts the model inferred.
  • The type of inference: a default, an assumption, an addition, or a boundary condition.
  • Its verification status: whether a scenario exists for it, and if so, what that scenario asserts.

Provenance is the important one. A clause that restates your request needs a glance. A clause the model inferred needs a decision.

Three verdicts

Approve. The clause is correct as written. It becomes part of the approved snapshot.

Reject. The clause is wrong. You write a reason — a sentence is enough — and only that clause is regenerated. Your reason is retained and shapes the next draft of that clause specifically.

Rejection is scoped. Rejecting one clause does not discard the other forty you already approved, and the diff after a revision shows exactly what changed.

Defer. You are not sure yet, and it does not block the rest. Deferred clauses are carried forward and stay visible in the completion map as uncovered.

Deferring is genuinely useful and underused. "I need to ask the payments team" is a better outcome than guessing, and a deferred clause that stays visible is better than a clause you approved hopefully and forgot about.

Why rejection reasons matter

A rejection reason is the highest-value signal in the whole system. It is a piece of human knowledge, expressed at the right moment, about the right thing.

We use it in three ways:

  • To regenerate the clause. The model sees the clause and your reason, and drafts again.
  • To shape future drafts. "We always use integer minor units" is not a fact about one clause. It is a convention. When the platform sees the same reason twice, it applies it as a convention for the rest of the project — which is how a project converges on a consistent style instead of you repeating yourself.
  • To build the project’s style guide. The accumulated reasons become a document that says how this team specifies things. It is checked into your repository, and it is applied to future drafts.

The third use is the one people underestimate. Over a few weeks of review, the platform ends up encoding how your team thinks about edge cases, not just what your team is building.

Approving everything

The review view will not stop you approving a hundred clauses in ninety seconds. Nothing can.

But the platform will show you, afterwards, what you did: the number of clauses approved per minute, the proportion that were inferred rather than stated, and the assertion-strength distribution of the scenarios attached to them. A specification approved that fast is a specification you have not verified, and the completion map will say so in those terms.

The stages are designed so that skipping review does not silently produce a broken result. It produces a result that is clearly labelled as unreviewed, and a trial environment that will find the difference.

What to look at first

If you have limited time, look at the clauses in this order:

  • Anything marked as an inference you did not expect. These are where the model guessed.
  • Clauses about failure and boundary behaviour. The expensive omissions live here.
  • Clauses with a weak assertion grade. A clause whose scenario asserts almost nothing will not catch its own regression. See assertion strength.

Everything else can be swept.

Next: run a trial.

Next