Blog ยท Requirements engineering

Walking the Walk: Deterministic, Governed Requirements Engineering

Deterministic. Intelligent. Governed. Over the past year those three words have become standard vocabulary across requirements tooling. Each describes how an engine should behave without saying how that behaviour is produced, and in practice the answer is usually an engineer, carrying the burden of catching whatever the engine missed. That makes the three words aspirations rather than capabilities, with very little for a buyer to check from a product page.

So rather than explain what governed, deterministic requirements engineering should look like, this post shows it. The recordings below were made on a real project, using QVscribe, ReqWriter and the QRA Platform. Each section names a claim, shows the screen, and says what you can check for yourself.

What each word has to mean to hold up

Deterministic. The same text, checked against the same rules in the same configuration, returns the same score and the same findings. A judgment that changed between runs would be an opinion, and an opinion cannot be filed as evidence.

Intelligent. The engine that writes and the engine that judges are separate mechanisms. ReqWriter is the generation engine, QVscribe is the evaluation engine, and the generation engine never grades its own work. Generation can vary and evaluation cannot, which is the point of separating them. You can afford a generation engine that varies precisely because the engine judging it does not.

Governed. Every version of a requirement stays on the record with its score, its findings, what changed and who changed it, so that "why does this requirement say that?" has an answer that was written down at the time rather than reconstructed afterwards.

Four questions to put the claims to the test

Those three definitions turn into four checks. None of them needs special access, and all four fit inside a single demo session, whichever product you are evaluating.

  1. Run it twice. Enter the same requirement, in the same configuration, on two different days. The score and the findings should match to the digit.
  2. Ask what judges the AI. If a model suggests a rewrite, find out what scores it, and whether that is the same model.
  3. Ask for a requirement's past. Pick one and ask to see its earlier versions, what changed between them, and what the checks said at each point.
  4. Compare two dates. Choose a past review date and ask for the score distribution then and now, with the added, deleted, improved and declined counts beside it.

The rest of this post is those four questions answered on screen.

Deterministic: the same requirement, the same findings

Every recording in this section uses the same requirement, taken from a file-transfer specification:

When CF receives a "Transfer File" command, if the command-specified is open, CF reject the command.

It is a realistic draft, with a missing noun after "command-specified", no imperative, and two trigger phrases in a single sentence.

QVscribe scores the requirement as it is entered and raises a No Imperatives alert, with the rule's description, an incorrect example and a correct example. Below it, an EARS check marked Non-Compliant names the Unwanted Behavior template, If <trigger>, then the <system name> shall <system response>, and lists the two triggers it found in the text. It then gives the four conditions the template requires. Exactly one imperative, no mixing of "when" and "if", an "if" that is eventually followed by "then", and a single named system.

QVscribe analysis of the Transfer File requirement, annotated: 1 score bar and alert count, 2 No Imperatives alert, 3 EARS Unwanted Behavior template, A and B the two triggers, 4 the four required conditions
QVscribe's analysis of the Transfer File requirement. The score bar and alert count (1) sit above a No Imperatives alert (2), because the sentence has no "shall". The EARS check matches the sentence to the Unwanted Behavior template (3) and lists the two triggers it found (A and B), the same two phrases highlighted in the requirement. Below them are the four conditions the sentence must meet to comply (4).

Checked again in Word, the same requirement returns the same analysis, with the same No Imperatives alert, the same examples, the same Unwanted Behavior template, the same two triggers and the same four conditions. Each requirement in the document carries its own score, the document carries an average of 4.27, and the pane offers Reanalyze, Create Snapshot and Generate Report alongside a link to the QRAcloud portal.

QVscribe in Word. The same requirement returns the same alert, template, triggers and conditions as it does in the browser. It ends on the Standard-style rewrite discussed further down.

That is half of what deterministic means. The other half is repetition over time, and it is the one thing a single recording cannot show, because a clip of one run is equally consistent with a checker that is deterministic and one that happened to agree with itself once. So here is the same requirement, in the same configuration, checked again on a later build of the product.

The same requirement and configuration on two builds, version 1.1.279 (orange) and 1.1.387 (blue). Both runs return the same alert, template, triggers and conditions.

QVscribe applies rules rather than a generative model, which is why the same sentence comes back the same way. The inputs are the text, the configuration and the rule set. The date an analysis runs on is not among them.

Intelligent: ReqWriter suggests, QVscribe scores, the engineer decides

The same file-transfer requirement goes through the generation step in both recordings, once with the rewrite style set to EARS and once to Standard.

In the browser, with EARS selected, the author chooses Suggest Rewrite and the suggestion appears beneath the original, with removed words struck through in red and added words in green:

If the command-specified file is open, then the CF shall reject the "Transfer File" command.

The suggestion carries its own score bar, which QVscribe produces rather than ReqWriter, and the author can copy it or decline it. In Word, with the style set to Standard, the pane offers a different suggestion for the same input:

CF shall reject a "Transfer File" command when CF receives the command and the command-specified file is open.

ReqWriter suggests an EARS rewrite. The score bar under the suggestion comes from QVscribe, not ReqWriter.

Two details in that pair are worth reading closely.

Both suggestions add the word "file" after "command-specified", which the original left out. That is a reasonable inference from the surrounding text, and it is also a change an engineer should confirm rather than accept silently, which is why nothing is applied until the author accepts it.

The first suggestion also drops the receipt event and keeps only the file-open condition. That is not an arbitrary choice. The EARS panel on the same screen states that a requirement cannot use "when" and "if" key phrases together, so resolving the conflict means one of the two triggers has to go. The reasoning is visible next to the result, which is the point. An engineer can see which rule drove the change and decide whether the right trigger survived.

Why the suggestions are allowed to differ

Those two differ because the styles differ, which is the engineer's choice to make. The freedom underneath that choice is the more interesting one.

There is no single correct sentence for a given requirement. Several phrasings can carry the same meaning, and which one serves best depends on the framework, the document around it and who reads it next. An engineer who does not like the first suggestion can ask for another at the same style, and that is only useful if the second one is allowed to come back different.

What stays fixed is the standard each suggestion is measured against, rather than the wording or the structure. The first suggestion is the case in point, because dropping the receipt event changes what the requirement says. QVscribe can see the structural conflict and score what comes back. It cannot decide which of the two triggers carries the behaviour the programme meant, and that is why nothing is applied until an engineer accepts it.

The tempting alternative is to remove that freedom, forcing generation through a rigid template and a controlled vocabulary so the output is predictable. Our CEO has written about why that trade goes badly in The Wrong Question. Constrain the generator hard enough and you have built the rails, but you have also removed the engine. The capability that made the thing worth having is the part you just took out. The rails are real; they belong at the point of judgment rather than welded onto the point of creation.

Why the judge is not a second generative model

That separation is not a house preference, and the cost of getting it wrong has been measured.

In April 2026 a study looked at rubric-based evaluation, where a judge returns a verdict against individual criteria rather than one holistic score, which is the closest published analogue to what happens here. It tested what happens when the model being judged is also the judge. On benchmarks whose criteria can be checked programmatically, judges can be more than 50 percent more likely to mark a failed criterion as satisfied when the output is their own. Pooling several judges reduced the effect without removing it.1

A generator asked to assess its own work does not fail loudly. It passes things that should not have passed, and it does so even on criteria a machine could have checked objectively.

Governed: a record that explains itself

Governance is the hardest claim to put in a screenshot, because it concerns what was recorded before anyone thought to ask. The recordings in this section come from the QRA Platform, running on a Smart Doorbell requirements document connected from Polarion.

An approval records that a person accepted something on a given day. What follows is a different kind of evidence, because it holds what the standard found at every version, and the two answer different questions. One says who signed. The other says what was wrong, when it cleared, and what is still outstanding.

Why does this requirement say that?

The history view for REQ-553 lists every version since continuous history began on September 22, 2026. Version 1, from that date, scored 1.0 with three alerts and one warning. Version 2, from October 19, scored 5.0 with no alerts and one warning, a change of +4.0 with three alerts cleared, 27 days apart, and the editor and status are recorded against each.

The text comparison shows exactly what the edit did. "Button" became "doorbell button", "should quickly" became "shall", and "Device" became "Device within [TIME: ___ seconds]". Beneath it, the findings say what those three changes bought. No imperatives, the non-specific temporal word "quickly" and the optional escape clause "should" were all cleared, while passive voice ("is pressed") is still present.

A red line on its own is history. A red line next to the findings it cleared is evidence.

The history of REQ-553. The text change from version 1 to version 2 sits above the findings it cleared, and the passive-voice warning it didn't, because "is pressed" is still in the text.

How have the scores moved since our last review?

The project view compares any past date with now. Set against October 1, 2026, the Smart Doorbell document reads an average of 4.26, down 0.02, across 50 requirements, which is 18 more than on October 1 after 20 were added and 2 deleted. Six requirements improved and two declined. The histogram shows 36 in the top band, up 14.

The small dip in the average sits beside a much larger body of requirements, and the view keeps both in frame, so a team can see that new work arrived rather than conclude that quality slipped. That comparison is only meaningful because the check is deterministic. The same text against the same rules returns the same result, so a difference between two dates is a difference in the requirements rather than a difference in the checker. A snapshot holds the score each version was given when it was taken, and changing your configuration later does not reach back and alter it. The timeline can show how the scores would look under a different configuration, which is a view rather than a revision. The two questions stay apart. What did we score then, and what would that work score against the bar we hold now.

The Smart Doorbell document compared with October 1. The added, deleted, improved and declined counts sit beside the average, so a small drop can be read in context.

Every project at a glance

The QRA Platform shows one tile per connected project, built from the requirements engineers are editing in Polarion. Each gives the number of requirements and documents, the contributors, how many requirements changed in the last seven days, a trend line per document and a histogram of its score distribution. The Requirements project holds 684 requirements across 11 documents, with 34 changed in the last week.

Read the spread rather than only the average. Two documents can both average 3.5 while one of them hides a cluster of ones, and a cluster of ones is where gate reviews tend to go sideways.

The projects page. Each tile shows a trend line and, under it, how the scores are spread.

The whole loop, where the requirements live

Everything above demonstrates one capability at a time. The last recording runs all three together inside Polarion, in the document engineers actually work in.

It opens on the Smart Doorbell summary dashboard, an average of 4.04 across 50 requirements, with 33 in the top band and 6 in the bottom. Filtering to the requirements scoring one out of five brings up the work worth doing first. Among them is REQ-742:

Where the Infrared Camera is equipped, the Infrared Blaster Range shall measure 15 feet and the infrared signal shall reach visitors that are at the typical distance from the Smart Doorbell.

QVscribe raises two alerts for multiple imperatives, one for the vague term "typical", a passive voice warning and an EARS non-compliance. ReqWriter reads those findings and suggests splitting the requirement in two. QVscribe then scores each half.

The first half, "Where the Infrared Camera is equipped, the Infrared Blaster Range shall be [MEASUREMENT: 15 feet]", scores five out of five. The second, covering visitors "located at the typical distance from the Smart Doorbell of [MEASUREMENT: ___ feet]", scores three.

The three is the part worth pausing on. As Morgan says, "we're not going to guess what you think typical is, so you've got to go back to your team and figure that out." The measurement stays blank and the requirement stays flagged until someone decides the number. Filling the gap with a plausible figure would have produced a five and hidden the open question.

REQ-742 split in two. The second statement leaves the distance blank and scores three until the team decides it.

Back in Polarion the accepted statements sit in the document as REQ-763 and REQ-549 with their scores beside them, next to REQ-553, the requirement from the history view.

That is the same document as the comparison earlier in this post, recorded at a different point in the month, which is why the two views report different averages for it.

Morgan's summary at the end of that recording is the shortest version of the whole argument. ReqWriter writes and QVscribe does the judging, and a suggestion never comes back scoring lower than the text you started with. As one medical device engineer put it to her, you need the part that generates the requirement and the judge that measures its quality, and "those should be two different things."

One objection worth answering

If ReqWriter is writing to the same rules QVscribe checks against, does a high score only tell you the requirement conforms?

Conformance is the thin reading. These rules are INCOSE and EARS, your own configuration and the approved language in your glossary, which is the same standard a reviewer applies when checking syntax and structure, applied the same way every time. What it covers is narrower than whether the engineering is right, and ReqWriter can be given those same boundaries, so it writes from the same knowledge an engineer writes from.

What no rule settles is intent, and that is where the engineer's attention lands once the laborious parts have moved to the engine. They keep the right to accept, amend or decline, which is a different thing from being the safety net that has to catch what the engine missed.

REQ-742 is that distinction in practice. A rule can detect that "typical" is vague. No rule can decide what number belongs in its place, because that is a programme decision, and some teams leave a term open on purpose. So Morgan sends it back to the team rather than letting the engine fill it in, and the score that results is the evidence. Something optimising for its own checker would have invented a plausible measurement and returned a five, while this returned a three and left the gap where it is.

The same holds from the other end. A requirement already scoring five can still be sent through a rewrite, because the standard it is measured against does not stand still. Teams learn what trips them up in review, and that learning lands in the configuration and the glossary, so a term that caused an argument last quarter becomes a rule this quarter. Changing the standard leaves your snapshots where they are, while giving you a way to look at everything already written against the new bar, fives included. Something pointed only at the number would have nothing to offer at five. Something pointed at the standard has something to offer every time the standard moves.

The gap between the conversation and the implementation

The requirements industry is not alone in talking about AI governance, deterministic evaluation and trustworthy output. These are becoming central questions across engineering and enterprise AI. What the research suggests is that implementation is running a long way behind the conversation.

A 2025 systematic review of 238 studies on generative AI in requirements engineering found that reproducibility was a concern in 66.8 percent of the research, while requirements management accounted for just 6.8 percent of the studies, an area the authors call underexplored. Only 1.3 percent had reached production-level integration.2

The broader enterprise picture is similar. An August 2026 HFS Research and TCS survey of 101 C-suite and technology leaders found 35 percent saying AI consistently delivers the business outcomes expected of it. One in four said they had the governance and controls needed to scale AI across the enterprise, and one in six trusted autonomous AI with business-critical work.3

The gap is becoming harder to ignore. Engineers are being given more AI-generated content to work with, while much of the responsibility for determining whether that content is reliable, compliant and fit for engineering use remains with the people reviewing it.

The answer cannot be to make human review the control system. Engineers decide about intent, system behaviour and acceptance. Repeatable evaluation, visibility into what changed and a record of what passed or failed should already exist in the tools they use, before any of those decisions come up. Governance cannot stop at telling engineers to check the output, and determinism cannot be a promise without a mechanism behind it.

That's the difference between talking about these principles and putting them into operation. The recordings above show what that looks like in practice.


1 J. Pombal, R. Rei and A. F. T. Martins, "Self-Preference Bias in Rubric-Based Evaluation of Large Language Models," arXiv:2604.06996, April 2026.

2 H. Cheng, J. H. Husen, Y. Lu, T. Racharak, N. Yoshioka, N. Ubayashi and H. Washizaki, "Generative AI for Requirements Engineering: A Systematic Literature Review," Software: Practice and Experience (2026), first published online November 4, 2025. DOI: 10.1002/spe.70029.

3 HFS Research and TCS, survey of 101 C-suite and technology leaders, published August 17, 2026.