Run a trial

An approved specification is a snapshot. A snapshot can be built. This page covers what happens next and, more importantly, what to do with the result.

Triggering the build

Approving all clauses commits the approved state to your repository and queues a build automatically. You can also re-run a previous build from its snapshot, which is how you tell "the code changed" apart from "the model behaved differently this time".

A build runs four layers. Each reports independently, and you can read the report for any of them without running the others:

Layer Question it answers
Lint Is the spec valid and consistent with our conventions?
Type check Do the implementation’s types hold together?
Cross-format consistency Does every scenario reference something that exists?
Scenario execution Do the specified behaviours actually hold?

The last one is where the interesting failures are. A scenario that fails tells you two things: either the implementation is wrong, or the specification is wrong. The report attributes the failure to the clause it came from, which is what makes it actionable — you can reject that clause and re-draft it rather than debugging generated code you did not write.

Reading a passing result carefully

A green build is not a finished product, and it is worth being precise about why.

The scenario suite proves that the behaviours in your specification hold. It says nothing about behaviours you did not specify. This is the central limitation of automated verification, and it is why the completion map is a first-class artifact rather than a badge.

Two things in particular are worth checking on a green build:

Assertion strength. The build reports the strength grade of every scenario. A build where every scenario is weak and every scenario passes is a build that has told you almost nothing. See assertion strength.

Coverage shape. The completion map shows which clauses are covered by executed scenarios, which are covered but only weakly, and which are not covered at all. A specification with ten clauses and eight covered is a different proposition from one with ten clauses and ten covered — and only the second is finished.

Using the trial environment

The environment is the point. It is a live instance with seeded data, deployed in the region closest to you.

Seed data is derived from your specification. It contains the entities your scenarios reference — a customer, an order in each state the spec mentions, the boundary case — so that you can exercise behaviours without inventing fixtures. By default it is synthetic. If you need a real dataset, that is an explicit opt-in, and you take responsibility for it.

Break it deliberately. The environment exists to be used hard. The most valuable thing you can do with it is the thing the scenarios do not cover:

  • Try the boundary the spec mentions in passing, but never asserts.
  • Try the input the spec does not mention at all.
  • Try two actions at once, when the spec only describes one.
  • Try a user who is not supposed to be able to do this. Authorisation gaps are the classic thing a scenario suite misses and a human notices in thirty seconds.

File findings against the scenario that should have caught them. When you find something broken, you attach it to the scenario that ought to have caught it. That produces three useful outcomes: the scenario gets strengthened, the defect is attributed correctly, and the platform learns that this class of gap matters for your domain.

This is how the completion map becomes honest over time. A scenario that fails to catch a real defect is downgraded, and the specification is fixed.

Finishing

When the trial satisfies you, you promote the build. That means deploying the artifact to your own infrastructure — the platform hands over the source, the build recipe, and the verification suite, and steps out of the way.

We do not hold your deployment. The output is yours, and promoting it should be an ordinary step in a pipeline you already have.

Next: the spec formats.