Approval workflow

Approval in Trigger & Trial operates on clauses, not documents. This page covers the mechanics.

Clause states

State Who sets it Meaning
draft The platform Written by the model, not yet seen by a human
in_review The platform, on first presentation Awaiting a decision
approved A reviewer Accepted as correct
rejected A reviewer, with a reason Refused; regenerating
deferred A reviewer Deliberately unresolved; carried forward, stays visible
implemented The build Covered by an executed scenario
verified The build Covered by a scenario that passed and was not degraded

approved is a human judgement about intent. verified is a mechanical fact about a build. The platform reports them separately and never substitutes one for the other.

Reviewing

The review view is a diff against the last state you saw. Every clause carries its provenance: which parts of your original request it came from, and which parts were inferred by the model.

Three verdicts, each with a distinct effect:

Approve. The clause becomes part of the next snapshot. Approving is a single action; no comment is required.

Reject. You give a reason, in a sentence or two. The clause is regenerated against that reason. Other clauses are untouched — approved ones stay approved, and the diff after regeneration shows only what changed in the rejected clause.

Defer. The clause is set aside. It is not approved, it is not regenerated, and it remains visible in the completion map as uncovered. Deferred clauses do not block a build.

Scoped regeneration

Rejecting a clause regenerates that clause. It does not re-draft the specification.

This matters more than it sounds. A full re-draft after each rejection would make rejection expensive, and people would stop rejecting — approving clauses they did not believe to keep the review moving. Scoped regeneration keeps rejection cheap, which is what makes it frequent, which is what makes the specification correct.

The consequence is that rejected clauses must be regenerable in isolation. Where a clause depends on another clause’s exact wording, the platform detects the dependency and regenerates both, showing you the second one as a consequence. It does not silently rewrite something you approved.

Rejection reasons compound

A rejection reason is retained, associated with the clause, and reused in three ways:

  • The clause is regenerated against the reason.
  • If a similar reason has been given before, it is applied as a project convention — so the same lesson is not needed twice.
  • Accumulated reasons become the project’s style guide, checked into your repository and applied to future drafts.

The style guide is generated from your own review decisions, not from a template. It is the mechanism by which the platform converges on how your team specifies things, rather than merely what your team is building.

Roles

Role Can do
viewer Read specs, builds, trial environments, and completion maps
developer Everything a viewer can, plus draft, review, reject, defer, approve, and trigger builds
maintainer Everything a developer can, plus manage the style guide and exemptions
owner Everything, plus manage members, billing, and tenant settings

Only developer and above can approve. Approval is a deliberate act with an audit trail attached, so we keep the permission set tight — but we do not require a second person. Single-person teams are the common case early on, and forcing a second approver would be theatre.

For teams that require it, a required-reviewer setting forces a specific member to approve before a snapshot can be built. This is a tenant setting, not a per-project one.

The audit trail

Every state change is recorded with the actor, the timestamp, the previous state, the new state, and the reason where one was given.

The important property: the audit trail is reconstructable from your repository. Approval commits to a branch and opens a pull request; the commit, the author, and the timestamp are Git’s, not ours. Our own record adds the clause-level detail that Git cannot hold — which clause was rejected and why — and it is exportable in the same format as everything else.

You should be able to answer "who approved this requirement, when, and on what basis" for any requirement, at any point, without asking us. If you have to ask us, we have failed.

What approval does not do

Approval does not guarantee that the implementation is correct. It records that a human accepted the clause as a correct statement of intent. The verification layers then check the implementation against that statement.

If a clause is wrong and you approved it anyway, the build will pass — faithfully, because the specification said so. The platform’s job is to make that outcome visible rather than to prevent it, and the completion map shows exactly which clauses were approved without independent verification of their correctness.

Next