About

Trigger & Trial exists because of a specific, repeated frustration: the review of a generated codebase is the most expensive step in shipping software, and it is the step that scales worst.

Why the name

The product is TNT — short for Trigger & Trial, pronounced "Trigger ‘N’ Trial", the same way the letters of an initialism usually are.

We are aware that TNT usually means something else entirely, and we took the name anyway for a reason that has nothing to do with explosives. It matches the domain: tnthub.com reads TNT Hub at a glance, so the three letters in our badge are the same three letters in the address bar. People who arrive from a link, from a bookmark, or from someone else’s message see the same word in both places, and the connection is made without us having to explain it.

The two halves of the name are also the two halves of the product. Trigger is the moment a reviewed specification becomes a build — an explicit, deliberate action that pins an immutable snapshot. Trial is what you get afterwards: a real, running environment you can use and break, and then throw away.

If you have seen the badge and wondered what TNT stands for: now you know, and if you arrived here by typing the domain, that was intentional.

The problem we started from

Modern coding agents make implementation cheap. Writing the first version of a service that reads a CSV, exposes four endpoints and handles the obvious error cases takes minutes. That is real progress, and it moves the bottleneck somewhere uncomfortable.

The bottleneck moves to review. A reviewer who does not trust the output has to read all of it. Trust is a function of volume, not of effort: a 400-line diff that is 95% correct still requires reading 400 lines to find the 5%. Worse, the reviewer’s attention is spent on implementation detail — the part that was supposed to be automatic — instead of on intent.

Meanwhile the thing that actually determines whether the software is right — the requirement — is the thing nobody writes down carefully. It lives in a chat message, a ticket title, and the reviewer’s memory of a conversation three weeks ago.

What we think the fix is

Specification-driven development is not new. Behaviour-driven development, contract-first design, acceptance-test-driven development, and "design documents" are all older ideas solving parts of this. What is new is that generating a specification is now cheap enough to be worth doing.

That changes the arithmetic. If a spec can be drafted in seconds, the interesting question is no longer "can we generate code" but "can we generate a specification good enough that a human is willing to approve it instead of reading code". A specification has a much better review economics than a diff: it is shorter, it is structured, and it can be read clause by clause.

So the platform is built around one loop: draft a spec, review it clause by clause, build against the approved snapshot, verify mechanically, hand back a live environment. The parts we care about most are unglamorous:

  • The review interface should make rejecting a single clause cheap and specific.
  • The completion map should not be able to lie. If a scenario asserts nothing, it should be visible that it asserts nothing.
  • The trial environment should be real enough that using it tells you something.
  • The audit trail should be reconstructable from ordinary version control, not from a proprietary log.

What we optimise for

Honest reporting over flattering numbers. A coverage percentage that counts a scenario asserting status == 200 as a meaningful check is worse than no metric, because it moves the goalposts. We grade assertions and show the grade next to the count.

Boring infrastructure. The control plane is a single process against a single relational database. No cache cluster, no message broker, no distributed lock service. Build logs are files and objects, not database rows. This is partly a cost decision and partly a decision about how many things can break at once.

Reversibility. Every step can be undone by ordinary means: a rejected clause, a reverted commit, a torn-down environment. Nothing important exists only inside our database.

No lock-in. Your specification is Gherkin and OpenAPI in your repository. If you leave, you leave with a specification your existing tools still understand and a codebase you still own. We are not trying to become the only place your requirements can live.

What we are not trying to be

We are not a general-purpose code generator, a low-code builder, or an IDE. We are not going to compete on the breadth of what can be scaffolded. The platform is deliberately narrow: contract-clear domains where behaviour can be stated precisely and checked mechanically.

We are also not going to tell you the automated verification replaces human acceptance. It does not. What it does is move the human attention from "does this code do what I meant" to "is this the right thing to have wanted" — which is the only place human attention was ever worth spending.

Where we are

Trigger & Trial is in early access. The platform is real, the pipeline runs end to end, and we are working with a small number of teams to find where the specification quality falls short. We are not publishing a general availability date, because we do not know it yet and would rather not guess.

If that sounds like a problem you have, <a href="/contact/">get in touch</a>.