How TNTHUB works

The pipeline has five stages. One of them needs a human. That is the design, not a limitation.

1. Request

You describe a behaviour in ordinary language. A ticket, a paragraph, a conversation transcript — anything that carries the requirement.

What the platform does with it: nothing yet. The request is the seed, not the specification. Most requests are underspecified, and the gap between what you said and what you meant is exactly where the next stage’s value comes from.

2. Draft

The model produces a specification in two native formats:

  • Gherkin feature files for behaviour — what the system does in response to what.
  • OpenAPI documents for interfaces — what the system exposes.

Three properties of this stage are worth knowing:

Inferences are marked. Anything the model concluded rather than read from you is tagged. Those tags are the highest-value part of your review: an unmarked assumption is one you might not notice, and an unmarked assumption is exactly where "the AI misunderstood me" comes from.

Conventions are applied. If your repository already contains feature files, the draft follows their conventions — naming, tag structure, step phrasing, Background usage. If it does not, the platform applies the Gherkin conventions and writes a style guide alongside so the next draft is more consistent.

Nothing is committed to your repository yet. Drafts live in the platform until you approve them.

3. Review

You work through the spec clause by clause in a diff-style view, and each clause can be independently approved, rejected, or deferred.

Rejecting a clause is scoped: only that clause is regenerated, and the diff you see afterwards shows exactly what changed. The reason you give on rejection is retained and used to shape the next draft of that clause.

When all clauses are approved, the approved state is committed to your repository as a commit on a branch, and a pull request is opened if you use that flow. That commit is the snapshot.

4. Build

The build runs against the snapshot and produces four results, each reported separately:

Layer Checks
Lint The specification is syntactically valid and follows your style rules
Type check The generated implementation’s types are internally consistent
Cross-format consistency Every operation a scenario references exists; every example matches its schema
Scenario execution The specified behaviours hold

The build is reproducible. The model version, every tool invocation, and every input are recorded, so a given snapshot can be rebuilt and will produce the same result — or a documented difference, if a provider changed something underneath us.

A failed layer does not fail the build silently. You get the specific failure, attributed to the specific clause or scenario that caused it.

5. Trial

A successful build provisions a disposable trial environment with seeded data, deployed in the region closest to you. It exists to be used hard.

The environment and the deliverable come from the same snapshot. There is no separate demo path with different behaviour, relaxed limits, or fake data that production does not use — the only difference is the data and the lifetime.

Environments are torn down automatically after their idle window, and on demand at any time.

What each stage is accountable for

It is easy to assume the platform guarantees "correctness". It does not, and the boundaries are worth stating plainly:

  • The draft is accountable for being complete and explicit about what it inferred.
  • The review is accountable for being cheap enough to do properly.
  • The build is accountable for reporting failures accurately, including failing when it should.
  • The verification is accountable for measuring the assertions that exist — and for grading their strength so weak ones are visible.
  • The trial is accountable for being the same artifact, not a flattering approximation.

None of them is accountable for guessing what you meant. That is why review is a real stage rather than a formality.

Next: write your first specification.

Next